ultralytics-thop 2.0.0__py3-none-any.whl → 2.0.2__py3-none-any.whl

thop/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "2.0.0"
+__version__ = "2.0.2"
 
 import torch
 

thop/fx_profile.py

@@ -13,7 +13,7 @@ if LooseVersion(torch.__version__) < LooseVersion("1.8.0"):
 
 
 def count_clamp(input_shapes, output_shapes):
-    """Ensures proper array sizes for tensors by clamping input and output shapes."""
+    """Ensures tensor array sizes are appropriate by clamping specified input and output shapes."""
     return 0
 
 
@@ -23,7 +23,7 @@ def count_mul(input_shapes, output_shapes):
 
 
 def count_matmul(input_shapes, output_shapes):
-    """Calculates the total number of operations for a matrix multiplication given input and output shapes."""
+    """Calculates matrix multiplication ops based on input and output tensor shapes for performance profiling."""
     in_shape = input_shapes[0]
     out_shape = output_shapes[0]
     in_features = in_shape[-1]
@@ -32,7 +32,7 @@ def count_matmul(input_shapes, output_shapes):
 
 
 def count_fn_linear(input_shapes, output_shapes, *args, **kwargs):
-    """Calculates total operations (FLOPs) for a linear layer given input and output shapes."""
+    """Calculates the total FLOPs for a linear layer, including bias operations if specified."""
     flops = count_matmul(input_shapes, output_shapes)
     if "bias" in kwargs:
         flops += output_shapes[0].numel()
@@ -43,7 +43,9 @@ from .vision.calc_func import calculate_conv
 
 
 def count_fn_conv2d(input_shapes, output_shapes, *args, **kwargs):
-    """Calculates total operations (FLOPs) for a 2D convolutional layer given input and output shapes."""
+    """Calculates total operations (FLOPs) for a 2D conv layer based on input and output shapes using
+    `calculate_conv`.
+    """
     inputs, weight, bias, stride, padding, dilation, groups = args
     if len(input_shapes) == 2:
         x_shape, k_shape = input_shapes
@@ -65,12 +67,12 @@ def count_nn_linear(module: nn.Module, input_shapes, output_shapes):
 
 
 def count_zero_ops(module: nn.Module, input_shapes, output_shapes, *args, **kwargs):
-    """Returns 0 for the given neural network module, input shapes, and output shapes."""
+    """Returns 0 for a neural network module, input shapes, and output shapes in PyTorch."""
     return 0
 
 
 def count_nn_conv2d(module: nn.Conv2d, input_shapes, output_shapes):
-    """Calculates total operations for a 2D convolutional neural network layer in a given neural network module."""
+    """Calculates FLOPs for a 2D Conv2D layer in an nn.Module using input and output shapes."""
     bias_op = 1 if module.bias is not None else 0
     out_shape = output_shapes[0]
 
@@ -82,7 +84,7 @@ def count_nn_conv2d(module: nn.Conv2d, input_shapes, output_shapes):
 
 
 def count_nn_bn2d(module: nn.BatchNorm2d, input_shapes, output_shapes):
-    """Calculate the total operations for a given nn.BatchNorm2d module based on its output shape."""
+    """Calculate FLOPs for an nn.BatchNorm2d layer based on the given output shape."""
     assert len(output_shapes) == 1, "nn.BatchNorm2d should only have one output"
     y = output_shapes[0]
     return 2 * y.numel()
@@ -127,9 +129,7 @@ def null_print(*args, **kwargs):
 
 
 def fx_profile(mod: nn.Module, input: th.Tensor, verbose=False):
-    """Profiles the given torch.nn Module to calculate total FLOPs for each operation and prints detailed node
-    information if verbose.
-    """
+    """Profiles nn.Module for total FLOPs per operation and prints detailed nodes if verbose."""
     gm: torch.fx.GraphModule = symbolic_trace(mod)
     ShapeProp(gm).propagate(input)
 

thop/profile.py

@@ -55,9 +55,7 @@ register_hooks = {
 
 
 def profile_origin(model, inputs, custom_ops=None, verbose=True, report_missing=False):
-    """Profiles a PyTorch model's operations and parameters by applying custom or default hooks and returns total
-    operations and parameters.
-    """
+    """Profiles a PyTorch model's operations and parameters, applying either custom or default hooks."""
     handler_collection = []
     types_collection = set()
     if custom_ops is None:
@@ -145,6 +143,7 @@ def profile(
     ret_layer_info=False,
     report_missing=False,
 ):
+    """Profiles a PyTorch model, returning total operations, parameters, and optionally layer-wise details."""
     handler_collection = {}
     types_collection = set()
     if custom_ops is None:

thop/rnn_hooks.py

@@ -4,7 +4,7 @@ from torch.nn.utils.rnn import PackedSequence
 
 
 def _count_rnn_cell(input_size, hidden_size, bias=True):
-    """Calculate the total operations for an RNN cell based on input size, hidden size, and bias configuration."""
+    """Calculate the total operations for an RNN cell given input size, hidden size, and optional bias."""
     total_ops = hidden_size * (input_size + hidden_size) + hidden_size
     if bias:
         total_ops += hidden_size * 2
@@ -13,7 +13,7 @@ def _count_rnn_cell(input_size, hidden_size, bias=True):
 
 
 def count_rnn_cell(m: nn.RNNCell, x: torch.Tensor, y: torch.Tensor):
-    """Counts RNN cell operations based on input, hidden size, bias, and batch size."""
+    """Counts the total RNN cell operations based on input tensor, hidden size, bias, and batch size."""
     total_ops = _count_rnn_cell(m.input_size, m.hidden_size, m.bias)
 
     batch_size = x[0].size(0)
@@ -23,7 +23,7 @@ def count_rnn_cell(m: nn.RNNCell, x: torch.Tensor, y: torch.Tensor):
 
 
 def _count_gru_cell(input_size, hidden_size, bias=True):
-    """Counts the total operations for a GRU cell based on input size, hidden size, and bias."""
+    """Counts the total operations for a GRU cell based on input size, hidden size, and bias configuration."""
     total_ops = 0
     # r = \sigma(W_{ir} x + b_{ir} + W_{hr} h + b_{hr}) \\
     # z = \sigma(W_{iz} x + b_{iz} + W_{hz} h + b_{hz}) \\
@@ -57,9 +57,7 @@ def count_gru_cell(m: nn.GRUCell, x: torch.Tensor, y: torch.Tensor):
 
 
 def _count_lstm_cell(input_size, hidden_size, bias=True):
-    """Calculates the total operations for an LSTM cell during inference given input size, hidden size, and optional
-    bias.
-    """
+    """Counts LSTM cell operations during inference based on input size, hidden size, and bias configuration."""
     total_ops = 0
 
     # i = \sigma(W_{ii} x + b_{ii} + W_{hi} h + b_{hi}) \\
@@ -82,9 +80,7 @@ def _count_lstm_cell(input_size, hidden_size, bias=True):
 
 
 def count_lstm_cell(m: nn.LSTMCell, x: torch.Tensor, y: torch.Tensor):
-    """Count the number of operations for a single LSTM cell in a given batch, updating the model's total operations
-    count.
-    """
+    """Counts and updates the total operations for an LSTM cell in a mini-batch during inference."""
     total_ops = _count_lstm_cell(m.input_size, m.hidden_size, m.bias)
 
     batch_size = x[0].size(0)
@@ -94,7 +90,7 @@ def count_lstm_cell(m: nn.LSTMCell, x: torch.Tensor, y: torch.Tensor):
 
 
 def count_rnn(m: nn.RNN, x, y):
-    """Calculate and update the total number of operations for a single RNN cell in a given batch."""
+    """Calculate and update the total number of operations for each RNN cell in a given batch."""
     bias = m.bias
     input_size = m.input_size
     hidden_size = m.hidden_size
@@ -131,7 +127,7 @@ def count_rnn(m: nn.RNN, x, y):
 
 
 def count_gru(m: nn.GRU, x, y):
-    """Calculate the total number of operations for a GRU layer in a neural network model."""
+    """Calculates total operations for a GRU layer, updating the model's operation count based on batch size."""
     bias = m.bias
     input_size = m.input_size
     hidden_size = m.hidden_size
@@ -168,9 +164,7 @@ def count_gru(m: nn.GRU, x, y):
 
 
 def count_lstm(m: nn.LSTM, x, y):
-    """Calculate the total operations for LSTM layers in a network, accounting for input size, hidden size, bias, and
-    bidirectionality.
-    """
+    """Calculate total operations for LSTM layers, including bidirectional, updating model's total operations."""
     bias = m.bias
     input_size = m.input_size
     hidden_size = m.hidden_size

thop/utils.py

@@ -22,7 +22,7 @@ prYellow = colorful_print(print, color=COLOR_YELLOW)
 
 
 def clever_format(nums, format="%.2f"):
-    """Formats numerical values into a more readable string with units (K, M, G, T) based on their magnitude."""
+    """Formats numbers into human-readable strings with units (K for thousand, M for million, etc.)."""
     if not isinstance(nums, Iterable):
         nums = [nums]
     clever_nums = []

thop/vision/basic_hooks.py

@@ -9,19 +9,19 @@ multiply_adds = 1
 
 
 def count_parameters(m, x, y):
-    """Calculate and update the total number of parameters in a given PyTorch model."""
+    """Calculate and return the total number of learnable parameters in a given PyTorch model."""
     m.total_params[0] = calculate_parameters(m.parameters())
 
 
 def zero_ops(m, x, y):
-    """Incrementally add the number of zero operations to the model's total operations count."""
+    """Incrementally add zero operations to the model's total operations count."""
     m.total_ops += calculate_zero_ops()
 
 
 def count_convNd(m: _ConvNd, x, y: torch.Tensor):
-    """Calculate and add the number of convolutional operations (FLOPs) to the model's total operations count."""
+    """Calculate and add the number of convolutional operations (FLOPs) for a ConvNd layer to the model's total ops."""
     x = x[0]
-    
+
     m.total_ops += calculate_conv2d_flops(
         input_size=list(x.shape),
         output_size=list(y.shape),
@@ -40,7 +40,7 @@ def count_convNd(m: _ConvNd, x, y: torch.Tensor):
 
 
 def count_convNd_ver2(m: _ConvNd, x, y: torch.Tensor):
-    """Calculates the total operations for a convolutional layer and updates the layer's total_ops attribute."""
+    """Calculates and updates total operations (FLOPs) for a convolutional layer in a PyTorch model."""
     x = x[0]
 
     # N x H x W (exclude Cout)
@@ -56,9 +56,7 @@ def count_convNd_ver2(m: _ConvNd, x, y: torch.Tensor):
 
 
 def count_normalization(m: nn.modules.batchnorm._BatchNorm, x, y):
-    """Calculate and add the FLOPs for a batch normalization layer, considering elementwise operations and possible
-    affine parameters.
-    """
+    """Calculate and add the FLOPs for a batch normalization layer, including elementwise and affine operations."""
     # https://github.com/Lyken17/pytorch-OpCounter/issues/124
     # y = (x - mean) / sqrt(eps + var) * weight + bias
     x = x[0]
@@ -80,7 +78,7 @@ def count_normalization(m: nn.modules.batchnorm._BatchNorm, x, y):
 
 
 def count_prelu(m, x, y):
-    """Calculate and update the total operation counts for a PReLU layer."""
+    """Calculate and update the total operation counts for a PReLU layer using input element number."""
     x = x[0]
 
     nelements = x.numel()
@@ -95,7 +93,7 @@ def count_relu(m, x, y):
 
 
 def count_softmax(m, x, y):
-    """Calculate and update the total operation counts for a Softmax layer."""
+    """Calculate and update the total operation counts for a Softmax layer in a PyTorch model."""
     x = x[0]
     nfeatures = x.size()[m.dim]
     batch_size = x.numel() // nfeatures
@@ -104,7 +102,7 @@ def count_softmax(m, x, y):
 
 
 def count_avgpool(m, x, y):
-    """Calculate and update the total operation counts for an AvgPool layer."""
+    """Calculate and update the total number of operations (FLOPs) for an AvgPool layer based on the output elements."""
     # total_div = 1
     # kernel_ops = total_add + total_div
     num_elements = y.numel()
@@ -112,7 +110,7 @@ def count_avgpool(m, x, y):
 
 
 def count_adap_avgpool(m, x, y):
-    """Calculate and update the total operation counts for an AdaptiveAvgPool layer."""
+    """Calculate and update the total operation counts for an AdaptiveAvgPool layer using kernel and element counts."""
     kernel = torch.div(torch.DoubleTensor([*(x[0].shape[2:])]), torch.DoubleTensor([*(y.shape[2:])]))
     total_add = torch.prod(kernel)
     num_elements = y.numel()
@@ -121,7 +119,7 @@ def count_adap_avgpool(m, x, y):
 
 # TODO: verify the accuracy
 def count_upsample(m, x, y):
-    """Update the total operations counter in the given module for supported upsampling modes."""
+    """Update total operations counter for upsampling layers based on the mode used."""
     if m.mode not in (
         "nearest",
         "linear",
@@ -137,9 +135,7 @@ def count_upsample(m, x, y):
 
 # nn.Linear
 def count_linear(m, x, y):
-    """Counts total operations for nn.Linear layers by calculating multiplications and additions based on input and
-    output elements.
-    """
+    """Counts total operations for nn.Linear layers using input and output element dimensions."""
     total_mul = m.in_features
     # total_add = m.in_features - 1
     # total_add += 1 if m.bias is not None else 0

thop/vision/calc_func.py

@@ -5,7 +5,7 @@ import torch
 
 
 def l_prod(in_list):
-    """Calculate the product of all elements in a list."""
+    """Compute the product of all elements in the input list."""
     res = 1
     for _ in in_list:
         res *= _
@@ -13,22 +13,22 @@ def l_prod(in_list):
 
 
 def l_sum(in_list):
-    """Calculate the sum of all elements in a list."""
+    """Calculate the sum of all numerical elements in a list."""
     return sum(in_list)
 
 
 def calculate_parameters(param_list):
-    """Calculate the total number of parameters in a list of tensors."""
+    """Calculate the total number of parameters in a list of tensors using the product of their shapes."""
     return sum(torch.DoubleTensor([p.nelement()]) for p in param_list)
 
 
 def calculate_zero_ops():
-    """Return a tensor initialized to zero."""
+    """Initializes and returns a tensor with all elements set to zero."""
     return torch.DoubleTensor([0])
 
 
 def calculate_conv2d_flops(input_size: list, output_size: list, kernel_size: list, groups: int, bias: bool = False):
-    """Calculate FLOPs for a Conv2D layer given input/output sizes, kernel size, groups, and bias flag."""
+    """Calculate FLOPs for a Conv2D layer using input/output sizes, kernel size, groups, and the bias flag."""
     # n, in_c, ih, iw = input_size
     # out_c, in_c, kh, kw = kernel_size
     in_c = input_size[1]
@@ -37,31 +37,29 @@ def calculate_conv2d_flops(input_size: list, output_size: list, kernel_size: lis
 
 
 def calculate_conv(bias, kernel_size, output_size, in_channel, group):
+    """Calculate FLOPs for convolutional layers given bias, kernel size, output size, in_channels, and groups."""
     warnings.warn("This API is being deprecated.")
-    """Inputs are all numbers!"""
     return torch.DoubleTensor([output_size * (in_channel / group * kernel_size + bias)])
 
 
 def calculate_norm(input_size):
-    """Input is a number not a array or tensor."""
+    """Compute the L2 norm of a tensor or array based on its input size."""
     return torch.DoubleTensor([2 * input_size])
 
 
 def calculate_relu_flops(input_size):
-    """Calculates the FLOPs for a ReLU activation function based on the input size."""
+    """Calculates the FLOPs for a ReLU activation function based on the input tensor's dimensions."""
     return 0
 
 
 def calculate_relu(input_size: torch.Tensor):
-    """Convert an input tensor to a DoubleTensor with the same value."""
+    """Convert an input tensor to a DoubleTensor with the same value (deprecated)."""
     warnings.warn("This API is being deprecated")
     return torch.DoubleTensor([int(input_size)])
 
 
 def calculate_softmax(batch_size, nfeatures):
-    """Calculate the number of FLOPs required for a softmax activation function based on batch size and number of
-    features.
-    """
+    """Compute FLOPs for a softmax activation given batch size and feature count."""
     total_exp = nfeatures
     total_add = nfeatures - 1
     total_div = nfeatures
@@ -70,19 +68,19 @@ def calculate_softmax(batch_size, nfeatures):
 
 
 def calculate_avgpool(input_size):
-    """Calculate the average pooling size given the input size."""
+    """Calculate the average pooling size for a given input tensor."""
     return torch.DoubleTensor([int(input_size)])
 
 
 def calculate_adaptive_avg(kernel_size, output_size):
-    """Calculate the number of operations for adaptive average pooling given kernel and output sizes."""
+    """Calculate FLOPs for adaptive average pooling given kernel size and output size."""
     total_div = 1
     kernel_op = kernel_size + total_div
     return torch.DoubleTensor([int(kernel_op * output_size)])
 
 
 def calculate_upsample(mode: str, output_size):
-    """Calculate the number of operations for upsample methods given the mode and output size."""
+    """Calculate the operations required for various upsample methods based on mode and output size."""
     total_ops = output_size
     if mode == "bicubic":
         total_ops *= 224 + 35
@@ -96,29 +94,29 @@ def calculate_upsample(mode: str, output_size):
 
 
 def calculate_linear(in_feature, num_elements):
-    """Calculate the linear operation count for an input feature and number of elements."""
+    """Calculate the linear operation count for given input feature and number of elements."""
     return torch.DoubleTensor([int(in_feature * num_elements)])
 
 
 def counter_matmul(input_size, output_size):
-    """Calculate the total number of operations for a matrix multiplication given input and output sizes."""
+    """Calculate the total number of operations for matrix multiplication given input and output sizes."""
     input_size = np.array(input_size)
     output_size = np.array(output_size)
     return np.prod(input_size) * output_size[-1]
 
 
 def counter_mul(input_size):
-    """Calculate the total number of operations for a matrix multiplication given input and output sizes."""
+    """Calculate the total number of operations for element-wise multiplication given the input size."""
     return input_size
 
 
 def counter_pow(input_size):
-    """Calculate the total number of scalar multiplications for a power operation given an input size."""
+    """Computes the total scalar multiplications required for power operations based on input size."""
     return input_size
 
 
 def counter_sqrt(input_size):
-    """Calculate the total number of scalar operations for a square root operation given an input size."""
+    """Calculate the total number of scalar operations required for a square root operation given an input size."""
     return input_size
 
 

{ultralytics_thop-2.0.0.dist-info → ultralytics_thop-2.0.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ultralytics-thop
-Version: 2.0.0
+Version: 2.0.2
 Summary: Ultralytics THOP package for fast computation of PyTorch model FLOPs and parameters.
 Author-email: Ligeng Zhu <ligeng.zhu+github@gmail.com>
 Maintainer: Glenn Jocher
@@ -13,7 +13,7 @@ Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Education
 Classifier: Intended Audience :: Science/Research
-Classifier: License :: OSI Approved :: MIT License
+Classifier: License :: OSI Approved :: GNU Affero General Public License v3 or later (AGPLv3+)
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
@@ -23,6 +23,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development
 Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Image Recognition
 Classifier: Operating System :: POSIX :: Linux
 Classifier: Operating System :: MacOS
 Classifier: Operating System :: Microsoft :: Windows
@@ -33,13 +34,13 @@ Requires-Dist: numpy
 Requires-Dist: torch
 
 <br>
-<img src="https://raw.githubusercontent.com/ultralytics/assets/main/logo/Ultralytics_Logotype_Original.svg" width="320">
+<a href="https://ultralytics.com" target="_blank"><img src="https://raw.githubusercontent.com/ultralytics/assets/main/logo/Ultralytics_Logotype_Original.svg" width="320" alt="Ultralytics logo"></a>
 
 # 🚀 THOP: PyTorch-OpCounter
 
 Welcome to the [THOP](https://github.com/ultralytics/thop) repository, your comprehensive solution for profiling PyTorch models by computing the number of Multiply-Accumulate Operations (MACs) and parameters. This tool is essential for deep learning practitioners to evaluate model efficiency and performance.
 
-[![GitHub Actions](https://github.com/ultralytics/thop/actions/workflows/format.yml/badge.svg)](https://github.com/ultralytics/thop/actions/workflows/main.yml) <a href="https://ultralytics.com/discord"><img alt="Discord" src="https://img.shields.io/discord/1089800235347353640?logo=discord&logoColor=white&label=Discord&color=blue"></a>
+[![GitHub Actions](https://github.com/ultralytics/thop/actions/workflows/format.yml/badge.svg)](https://github.com/ultralytics/thop/actions/workflows/main.yml) <a href="https://ultralytics.com/discord"><img alt="Discord" src="https://img.shields.io/discord/1089800235347353640?logo=discord&logoColor=white&label=Discord&color=blue"></a> <a href="https://community.ultralytics.com"><img alt="Ultralytics Forums" src="https://img.shields.io/discourse/users?server=https%3A%2F%2Fcommunity.ultralytics.com&logo=discourse&label=Forums&color=blue"></a>
 
 ## 📄 Description
 
@@ -68,9 +69,10 @@ pip install --upgrade git+https://github.com/ultralytics/thop.git
 To profile a model, you can use the following example:
 
 ```python
+import torch
 from torchvision.models import resnet50
+
 from thop import profile
-import torch
 
 model = resnet50()
 input = torch.randn(1, 3, 224, 224)
@@ -170,7 +172,7 @@ We welcome community contributions to enhance THOP. Please check our [Contributi
 
 ## 📄 License
 
-THOP is licensed under the AGPL-3.0 License. For more information, see the [LICENSE](https://github.com/ultralytics/thop/blob/master/LICENSE) file.
+THOP is licensed under the AGPL-3.0 License. For more information, see the [LICENSE](https://github.com/ultralytics/thop/blob/main/LICENSE) file.
 
 ## 📮 Contact
 
@@ -188,7 +190,7 @@ For bugs or feature requests, please open an issue on [GitHub Issues](https://gi
   <img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%" alt="space">
   <a href="https://www.tiktok.com/@ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-tiktok.png" width="3%" alt="Ultralytics TikTok"></a>
   <img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%" alt="space">
-  <a href="https://www.instagram.com/ultralytics/"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-instagram.png" width="3%" alt="Ultralytics Instagram"></a>
+  <a href="https://ultralytics.com/bilibili"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-bilibili.png" width="3%" alt="Ultralytics BiliBili"></a>
   <img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%" alt="space">
   <a href="https://ultralytics.com/discord"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-discord.png" width="3%" alt="Ultralytics Discord"></a>
 </div>

ultralytics_thop-2.0.2.dist-info/RECORD

@@ -0,0 +1,13 @@
+thop/__init__.py,sha256=jcR-yZnxf2TgpJ9VTv52KMkgWkpS1rCPQFOZWCUOS6g,146
+thop/fx_profile.py,sha256=u1eNvsRBTl9u0jJ6ymgrnrJP1VSLpAZkaEvm4D2mrI4,8172
+thop/profile.py,sha256=7ZMuGia9jIz_aeuUWXD_wb5WgunuaPx7nfaUQVf8CzY,7911
+thop/rnn_hooks.py,sha256=IwxLvVvbeo5skThdg3BKXm08_0GsM8FI2QM_alQcCB8,6432
+thop/utils.py,sha256=SP5QWanMqVRieDoYGQN-7lftZmYXohn2E_m3cP17tS4,1413
+thop/vision/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+thop/vision/basic_hooks.py,sha256=tKclhcddDByXrIXiI9u224nIKTbqWfp2J3hqIUYK6Hc,4639
+thop/vision/calc_func.py,sha256=5YbWp48XRbJYzSRkAFMr5xlM4o5BbjTcU6rHSKPkD6I,4291
+ultralytics_thop-2.0.2.dist-info/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
+ultralytics_thop-2.0.2.dist-info/METADATA,sha256=-9izM8Samq6PGBEdy3H0VuDM-lgZPu56qkqsLpPYUUI,8912
+ultralytics_thop-2.0.2.dist-info/WHEEL,sha256=HiCZjzuy6Dw0hdX5R3LCFPDmFS4BWl8H-8W39XfmgX4,91
+ultralytics_thop-2.0.2.dist-info/top_level.txt,sha256=HQ7D0gSvDJ31CNR-f0EuXNVve05RYBmwyIkHQKiEhU8,5
+ultralytics_thop-2.0.2.dist-info/RECORD,,

{ultralytics_thop-2.0.0.dist-info → ultralytics_thop-2.0.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.43.0)
+Generator: setuptools (72.2.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

ultralytics_thop-2.0.0.dist-info/RECORD

@@ -1,13 +0,0 @@
-thop/__init__.py,sha256=atkwStCUTA2zIEim2pGqbVkiIS0T_lSE1d7ajoxa2fA,146
-thop/fx_profile.py,sha256=NDObo07yrBf7B6ENltPMR9Cr1IolEumRkeTI6pXhpVs,8210
-thop/profile.py,sha256=z89mX1zVr_42axKbhgz9k2MJbgBLaBPt30lYT_PcWuA,7848
-thop/rnn_hooks.py,sha256=GYuKaNPEdZzTuqNCrJpTBjeQHsWs65UXCCaViS2giik,6485
-thop/utils.py,sha256=V_Pj_qC6RjqMyuiSX05eeUujT07hZQV-xobCIabjDds,1422
-thop/vision/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-thop/vision/basic_hooks.py,sha256=oOuHk5iPjRJjUuijY8Zppqr1s1abKV0y08N4DuqZGVg,4619
-thop/vision/calc_func.py,sha256=RE-qQWGjZIlRx8CNKjF-ZY7aS0WShPkvnOAYvQA8z8I,4130
-ultralytics_thop-2.0.0.dist-info/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
-ultralytics_thop-2.0.0.dist-info/METADATA,sha256=JdsrGLxGdfqT1xnZsmaz5ejScJG5ALlTVjE4jNqwxQs,8525
-ultralytics_thop-2.0.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-ultralytics_thop-2.0.0.dist-info/top_level.txt,sha256=HQ7D0gSvDJ31CNR-f0EuXNVve05RYBmwyIkHQKiEhU8,5
-ultralytics_thop-2.0.0.dist-info/RECORD,,