Performance Benchmarks¶

import autotimm as at  # recommended alias
from autotimm import ObjectDetector, MetricConfig

# For real-time applications
model = ObjectDetector(
    backbone="mobilenetv3_large_100",
    num_classes=80,
    metrics=[...],
    fpn_channels=128,  # Smaller FPN
)

# For high accuracy
model = ObjectDetector(
    backbone="swin_small_patch4_window7_224",
    num_classes=80,
    metrics=[...],
    fpn_channels=256,
)

from autotimm import AutoTrainer, ImageDataModule

# 1. Reduce batch size
data = ImageDataModule(batch_size=8)  # Instead of 32

# 2. Use gradient accumulation
trainer = AutoTrainer(
    accumulate_grad_batches=4,  # Effective batch = 8 * 4 = 32
)

# 3. Use mixed precision
trainer = AutoTrainer(precision="bf16-mixed")

# 4. Reduce image size
data = ImageDataModule(image_size=160)  # Instead of 224

import time
import torch
from autotimm import ImageClassifier, MetricConfig


def benchmark_model(backbone, num_classes=10, image_size=224, batch_size=32, warmup=10, iterations=100):
    """Benchmark model inference speed."""
    metrics = [
        MetricConfig(
            name="accuracy",
            backend="torchmetrics",
            metric_class="Accuracy",
            params={"task": "multiclass"},
            stages=["val"],
        )
    ]

    model = ImageClassifier(
        backbone=backbone,
        num_classes=num_classes,
        metrics=metrics,
    )
    model.eval()

    if torch.cuda.is_available():
        model = model.cuda()
        device = "cuda"
    else:
        device = "cpu"

    # Create dummy input
    x = torch.randn(batch_size, 3, image_size, image_size).to(device)

    # Warmup
    with torch.inference_mode():
        for _ in range(warmup):
            _ = model(x)

    if device == "cuda":
        torch.cuda.synchronize()

    # Benchmark
    start = time.perf_counter()
    with torch.inference_mode():
        for _ in range(iterations):
            _ = model(x)

    if device == "cuda":
        torch.cuda.synchronize()

    end = time.perf_counter()

    total_time = end - start
    avg_time = total_time / iterations * 1000  # ms
    throughput = batch_size * iterations / total_time

    print(f"{backbone}:")
    print(f"  Average latency: {avg_time:.2f} ms")
    print(f"  Throughput: {throughput:.1f} images/sec")

    return avg_time, throughput


# Run benchmarks
backbones = [
    "mobilenetv3_small_100",
    "efficientnet_b0",
    "resnet50",
    "vit_base_patch16_224",
]

for backbone in backbones:
    benchmark_model(backbone)