### Install ultralytics-thop from GitHub

Source: https://github.com/ultralytics/thop/blob/main/README.md

Installs or upgrades the ultralytics-thop package directly from its GitHub repository. This method is useful for obtaining the latest features and bug fixes that may not yet be released on PyPI.

```bash
pip install --upgrade git+https://github.com/ultralytics/thop.git
```

--------------------------------

### Profile a PyTorch Model with THOP

Source: https://github.com/ultralytics/thop/blob/main/README.md

Demonstrates basic usage of the THOP library to profile a PyTorch model. It shows how to import the `profile` function, load a model (e.g., ResNet50), create a dummy input tensor, and then call `profile` to get the MACs and parameters. The output provides a measure of the model's computational complexity.

```python
import torch
from torchvision.models import resnet50  # Example model

from thop import profile  # Import the profile function from THOP

# Load a pre-trained model (e.g., ResNet50)
model = resnet50()

# Create a dummy input tensor matching the model's expected input shape
dummy_input = torch.randn(1, 3, 224, 224)

# Profile the model
macs, params = profile(model, inputs=(dummy_input,))

print(f"MACs: {macs}, Parameters: {params}")
# Expected output: MACs: 4139975680.0, Parameters: 25557032.0
```

--------------------------------

### Install ultralytics-thop via Pip

Source: https://github.com/ultralytics/thop/blob/main/README.md

Installs the ultralytics-thop package using pip. This is the standard method for adding the library to your Python environment. It ensures you get a stable release from PyPI.

```bash
pip install ultralytics-thop
```

--------------------------------

### Profile PyTorch Model with Custom Operations

Source: https://context7.com/ultralytics/thop/llms.txt

Profiles PyTorch models that include custom or third-party modules. This is achieved by providing custom counting functions for these modules via the `custom_ops` parameter. The example demonstrates profiling a `CustomConvBlock` by defining a specific function to count its operations.

```python
import torch
import torch.nn as nn
from thop import profile

# Define a custom module
class CustomConvBlock(nn.Module):
    def __init__(self, in_channels, out_channels):
        super().__init__()
        self.conv = nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1)
        self.bn = nn.BatchNorm2d(out_channels)
        self.relu = nn.ReLU(inplace=True)

    def forward(self, x):
        x = self.conv(x)
        x = self.bn(x)
        x = self.relu(x)
        return x

# Define custom counting function for the custom module
def count_custom_conv_block(module, input, output):
    # Calculate MACs for convolution in the block
    # Conv2d MACs = output_height * output_width * kernel_h * kernel_w * in_channels * out_channels
    x = input[0]
    y = output

    _, _, H, W = y.shape
    kernel_h, kernel_w = module.conv.kernel_size
    in_c = module.conv.in_channels
    out_c = module.conv.out_channels
    groups = module.conv.groups

    conv_macs = (kernel_h * kernel_w * in_c * out_c * H * W) / groups

    # BatchNorm MACs (2 operations per element: subtract mean, divide by std)
    bn_macs = 2 * y.numel()

    # ReLU MACs (comparison operation, typically considered zero-cost)
    relu_macs = 0

    total_macs = conv_macs + bn_macs + relu_macs
    module.total_ops += torch.DoubleTensor([total_macs])

# Create model with custom block
model = nn.Sequential(
    CustomConvBlock(3, 64),
    CustomConvBlock(64, 128),
    nn.AdaptiveAvgPool2d((1, 1)),
    nn.Flatten(),
    nn.Linear(128, 10)
)

# Profile with custom operations
input_tensor = torch.randn(1, 3, 224, 224)
macs, params = profile(
    model,
    inputs=(input_tensor,),
    custom_ops={CustomConvBlock: count_custom_conv_block},
    verbose=True
)

print(f"MACs: {macs:,.0f}, Parameters: {params:,.0f}")
```

--------------------------------

### Calculate MACs for Custom PyTorch Module using THOP

Source: https://github.com/ultralytics/thop/blob/main/README.md

This Python function demonstrates how to calculate MACs for a custom module, specifically a Conv2d layer, within the THOP profiling framework. It assumes the module is part of a larger model and accumulates its MACs to `module.total_ops`. This example is a simplified representation and requires actual implementation based on the specific module's architecture.

```python
import torch
import torch.nn as nn
from thop import profile

# Assume YourCustomModule is defined elsewhere and incorporates nn.Conv2d
class YourCustomModule(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv = nn.Conv2d(3, 16, kernel_size=3, stride=1, padding=1)

    def forward(self, x):
        return self.conv(x)

# This function should calculate and return the MACs for the module's operations
def count_your_custom_module(module, x, y):
    # Example: Calculate MACs for the conv layer
    # Note: This is a simplified example. Real calculations depend on the module's specifics.
    # MACs = output_height * output_width * kernel_height * kernel_width * in_channels * out_channels
    # For simplicity, we'll just assign a placeholder value or use a helper if available
    # In a real scenario, you'd implement the precise MAC calculation here.
    # For nn.Conv2d, THOP usually handles it, but this demonstrates the concept.
    macs = 0  # Placeholder: Implement actual MAC calculation based on module logic
    # You might need access to module properties like kernel_size, stride, padding, channels etc.
    # Example for a Conv2d layer (simplified):
    if isinstance(module, nn.Conv2d):
        _, _, H, W = y.shape  # Output shape
        k_h, k_w = module.kernel_size
        in_c = module.in_channels
        out_c = module.out_channels
        groups = module.groups
        macs = (k_h * k_w * in_c * out_c * H * W) / groups
    module.total_ops += torch.DoubleTensor([macs])  # Accumulate MACs


# Instantiate a model containing your custom module
model = YourCustomModule()  # Or a larger model incorporating this module

# Create a dummy input
dummy_input = torch.randn(1, 3, 224, 224)

# Profile the model, providing the custom operation mapping
macs, params = profile(model, inputs=(dummy_input,), custom_ops={nn.Conv2d: count_your_custom_module})

print(f"Custom MACs: {macs}, Parameters: {params}")
# Expected output: Custom MACs: 87457792.0, Parameters: 1792.0
```

--------------------------------

### Display Model Comparison Table

Source: https://context7.com/ultralytics/thop/llms.txt

This snippet shows how to format and print a comparison table of model performance metrics like MACs and Parameters. It iterates through a list of results, ensuring alignment and readability.

```python
results = [
    {'Model': 'ResNet50', 'MACs': '4.140G', 'Parameters': '25.557M'},
    {'Model': 'MobileNetV2', 'MACs': '0.333G', 'Parameters': '3.505M'},
    {'Model': 'VGG16', 'MACs': '15.614G', 'Parameters': '138.358M'}
]

print(f"{'Model':<15} {'MACs':<12} {'Parameters':<12}")
print("-" * 40)
for r in results:
    print(f"{r['Model']:<15} {r['MACs']:<12} {r['Parameters']:<12}")
```

--------------------------------

### Profile FX-based Models with PyTorch FX

Source: https://context7.com/ultralytics/thop/llms.txt

This advanced snippet utilizes PyTorch's FX framework for symbolic tracing and profiling, suitable for dynamic models. It requires PyTorch version 1.8.0 or higher. The code defines a simple model, profiles it using `fx_profile`, and includes a fallback to standard `profile` if FX profiling fails. Dependencies: PyTorch (>= 1.8.0), thop.

```python
import torch
import torch.nn as nn
from thop.fx_profile import fx_profile
from thop import clever_format, profile

# Create a simple model
class SimpleNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear1 = nn.Linear(100, 50)
        self.linear2 = nn.Linear(100, 50)
        self.relu = nn.ReLU()

    def forward(self, x):
        # Dynamic computation graph
        out1 = self.linear1(x)
        out2 = self.linear2(x).clamp(min=0.0, max=1.0)
        return self.relu(out1 + out2)

model = SimpleNet()
input_tensor = torch.randn(20, 100)

# Profile using FX (symbolic tracing)
try:
    total_flops = fx_profile(model, input_tensor, verbose=True)
    flops_str = clever_format([total_flops], "%.3f")[0]
    print(f"\nTotal FLOPs (FX Profile): {flops_str}")
except Exception as e:
    print(f"FX profiling not available: {e}")
    # Fallback to standard profiling
    macs, params = profile(model, inputs=(input_tensor,), verbose=False)
    macs_str, params_str = clever_format([macs, params], "%.3f")
    print(f"Standard Profile - MACs: {macs_str}, Parameters: {params_str}")
```

--------------------------------

### Format THOP Output for Readability in Python

Source: https://github.com/ultralytics/thop/blob/main/README.md

This Python code snippet demonstrates how to use the `clever_format` function from the THOP library to make the output of MACs and parameter counts more human-readable. It takes a list containing MACs and parameters and formats them into strings with appropriate units (e.g., G for Giga, M for Mega). This is useful for quick analysis and comparison of model complexity.

```python
import torch
from torchvision.models import resnet50

from thop import clever_format, profile

model = resnet50()
dummy_input = torch.randn(1, 3, 224, 224)
macs, params = profile(model, inputs=(dummy_input,))

# Format the numbers into a readable format (e.g., 4.14 GMac, 25.56 MParams)
macs_readable, params_readable = clever_format([macs, params], "%.3f")

print(f"Formatted MACs: {macs_readable}, Formatted Parameters: {params_readable}")
# Expected output: Formatted MACs: 4.140G, Formatted Parameters: 25.557M
```

--------------------------------

### Profile CNN Model with Layer-wise Information

Source: https://context7.com/ultralytics/thop/llms.txt

This Python code demonstrates how to profile a Convolutional Neural Network (CNN) with layer-by-layer detail using the `thop` library. It requires `torch` and `torch.nn`. The `ret_layer_info=True` argument enables detailed breakdown of MACs and parameters per layer.

```python
import torch
import torch.nn as nn
from thop import profile

class SimpleCNN(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(3, 64, kernel_size=3, padding=1)
        self.relu1 = nn.ReLU()
        self.pool1 = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(64, 128, kernel_size=3, padding=1)
        self.relu2 = nn.ReLU()
        self.pool2 = nn.MaxPool2d(2, 2)
        self.fc = nn.Linear(128 * 8 * 8, 10)

    def forward(self, x):
        x = self.pool1(self.relu1(self.conv1(x)))
        x = self.pool2(self.relu2(self.conv2(x)))
        x = x.view(x.size(0), -1)
        x = self.fc(x)
        return x

model = SimpleCNN()
input_tensor = torch.randn(1, 3, 32, 32)

# Profile with layer information
total_macs, total_params, layer_info = profile(
    model,
    inputs=(input_tensor,),
    ret_layer_info=True,
    verbose=False
)

print(f"Total MACs: {total_macs:,.0f}")
print(f"Total Parameters: {total_params:,.0f}")
print("\nLayer-wise breakdown:")

def print_layer_info(layer_dict, prefix=""):
    for layer_name, (macs, params, nested) in layer_dict.items():
        print(f"{prefix}{layer_name}: MACs={macs:,.0f}, Params={params:,.0f}")
        if nested:
            print_layer_info(nested, prefix + "  ")

print_layer_info(layer_info)
```

--------------------------------

### Format Output with Clever Format Utility

Source: https://context7.com/ultralytics/thop/llms.txt

Utilizes the `clever_format` function to convert raw MAC and parameter counts into human-readable strings with appropriate units (K, M, G, T). This function takes a list containing MACs and parameters and a format string, returning formatted string representations.

```python
import torch
from torchvision.models import resnet50, mobilenet_v2, vgg16
from thop import profile, clever_format

# Profile multiple models for comparison
models = {
    'ResNet50': resnet50(pretrained=False),
    'MobileNetV2': mobilenet_v2(pretrained=False),
    'VGG16': vgg16(pretrained=False)
}

input_tensor = torch.randn(1, 3, 224, 224)
results = []

for name, model in models.items():
    model.eval()
    macs, params = profile(model, inputs=(input_tensor,), verbose=False)

    # Format numbers into readable format
    macs_str, params_str = clever_format([macs, params], "%.3f")

    results.append({
        'Model': name,
        'MACs': macs_str,
        'Parameters': params_str,
        'Raw MACs': macs,
        'Raw Params': params
    })

```

--------------------------------

### Profile RNN/LSTM/GRU Models with THOP

Source: https://context7.com/ultralytics/thop/llms.txt

This Python code demonstrates profiling recurrent neural networks (RNN, LSTM, GRU) using the `thop` library. It handles sequential data and bidirectional layers. The `clever_format` function is used for human-readable output of MACs and parameters.

```python
import torch
import torch.nn as nn
from thop import profile, clever_format

class LSTMModel(nn.Module):
    def __init__(self, input_size=100, hidden_size=256, num_layers=2, num_classes=10):
        super().__init__()
        self.lstm = nn.LSTM(
            input_size=input_size,
            hidden_size=hidden_size,
            num_layers=num_layers,
            batch_first=True,
            bidirectional=True
        )
        self.fc = nn.Linear(hidden_size * 2, num_classes)  # *2 for bidirectional

    def forward(self, x):
        lstm_out, (h_n, c_n) = self.lstm(x)
        # Use the last time step output
        out = self.fc(lstm_out[:, -1, :])
        return out

model = LSTMModel(input_size=100, hidden_size=256, num_layers=2, num_classes=10)
sequence_length = 50
batch_size = 1
input_tensor = torch.randn(batch_size, sequence_length, 100)

# Profile the LSTM model
macs, params = profile(model, inputs=(input_tensor,), verbose=False)
macs_str, params_str = clever_format([macs, params], "%.3f")

print(f"LSTM Model Profiling:")
print(f"  MACs: {macs_str}")
print(f"  Parameters: {params_str}")
print(f"  Input shape: {tuple(input_tensor.shape)}")
print(f"  Sequence length: {sequence_length}")

# Compare different RNN types
models = {
    'LSTM': nn.LSTM(100, 256, num_layers=2, batch_first=True),
    'GRU': nn.GRU(100, 256, num_layers=2, batch_first=True),
    'RNN': nn.RNN(100, 256, num_layers=2, batch_first=True)
}

print("\nRNN Type Comparison:")
for name, rnn_model in models.items():
    macs, params = profile(rnn_model, inputs=(input_tensor,), verbose=False)
    macs_str, params_str = clever_format([macs, params], "%.3f")
    print(f"{name:<6} - MACs: {macs_str:<10} Parameters: {params_str}")
```

--------------------------------

### Profile PyTorch Model for MACs and Parameters

Source: https://context7.com/ultralytics/thop/llms.txt

Profiles a PyTorch model to calculate the total number of Multiply-Accumulate Operations (MACs) and parameters. It takes a PyTorch model and a dummy input tensor as input, returning MACs and parameters as floating-point numbers. The `verbose=True` option prints detailed profiling information.

```python
import torch
from torchvision.models import resnet50
from thop import profile

# Load a pre-trained ResNet50 model
model = resnet50(pretrained=False)
model.eval()

# Create a dummy input tensor (batch_size=1, channels=3, height=224, width=224)
input_tensor = torch.randn(1, 3, 224, 224)

# Profile the model to get MACs and parameters
macs, params = profile(model, inputs=(input_tensor,), verbose=True)

print(f"Total MACs: {macs:,.0f}")
print(f"Total Parameters: {params:,.0f}")
```

--------------------------------

### Profile PyTorch Model with Missing Module Reporting

Source: https://context7.com/ultralytics/thop/llms.txt

This snippet demonstrates how to profile a PyTorch model using the `thop.profile` function with missing module reporting enabled. It reports total MACs and parameters, and any unrecognized modules are flagged as warnings with zero contribution. Dependencies: PyTorch, thop.

```python
from thop import profile
import torch

# Assume 'model' and 'input_tensor' are defined
# model = YourPyTorchModel()
# input_tensor = torch.randn(batch_size, channels, height, width)

print("Profiling with missing module detection:")
macs, params = profile(
    model,
    inputs=(input_tensor,),
    verbose=True,
    report_missing=True
)

print(f"\nTotal MACs: {macs:,\.0f}")
print(f"Total Parameters: {params:,\.0f}")
# Any unrecognized modules will be reported in red text as warnings
# They will be treated as zero MACs and zero parameters
```

--------------------------------

### Define Custom Rules for Third-Party Modules in THOP

Source: https://github.com/ultralytics/thop/blob/main/README.md

Illustrates how to define custom profiling rules for third-party or custom PyTorch modules when using THOP. This involves creating a custom module class and then defining a corresponding counting function, which can then be passed to the `profile` function via the `custom_ops` argument to ensure accurate MACs and parameter counts for these non-standard components.

```python
import torch
import torch.nn as nn

from thop import profile


# Define your custom module
class YourCustomModule(nn.Module):
    def __init__(self):
        super().__init__()
        # Define layers, e.g., a convolution
        self.conv = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1)

    def forward(self, x):
        return self.conv(x)


# Define a custom counting function for your module

```

--------------------------------

### Profile Model with Missing Module Reporting

Source: https://context7.com/ultralytics/thop/llms.txt

This Python snippet demonstrates how to use the `thop` library to profile a model that may contain unsupported modules. Setting `report_missing=True` will generate warnings for any layers that `thop` cannot profile, aiding in debugging and extension.

```python
import torch
import torch.nn as nn
from thop import profile

class MixedModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv = nn.Conv2d(3, 64, kernel_size=3)
        self.bn = nn.BatchNorm2d(64)
        self.dropout = nn.Dropout(0.5)
        # Custom activation that THOP may not recognize
        self.custom_activation = nn.PReLU()

    def forward(self, x):
        x = self.conv(x)
        x = self.bn(x)
        x = self.custom_activation(x)
        x = self.dropout(x)
        return x

model = MixedModel()
input_tensor = torch.randn(1, 3, 224, 224)

# Profile with missing module reporting enabled
macs, params = profile(model, inputs=(input_tensor,), report_missing=True, verbose=False)

print(f"Model MACs: {macs}")
print(f"Model Parameters: {params}")
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.