⚡️ Speed up function load_backbone by 11%

[codeflash-ai]

📄 11% (0.11x) speedup for load_backbone in src/transformers/utils/backbone_utils.py

⏱️ Runtime : 39.1 microseconds → 35.3 microseconds (best of 6 runs)

📝 Explanation and details

The optimized code achieves a 10% speedup through three key micro-optimizations:

1. Conditional assignment optimization: Changed backbone_kwargs = {} if backbone_kwargs is None else backbone_kwargs to a conditional block that only executes the assignment when needed. This eliminates the ternary operator overhead and redundant assignment when backbone_kwargs is already defined.

2. Early returns instead of variable assignments: Replaced intermediate variable assignments with direct returns in the use_timm_backbone and use_pretrained_backbone branches. This eliminates unnecessary variable creation and reduces stack operations.

3. Changed elif to if for independent conditions: The use_pretrained_backbone check was changed from elif to if since these conditions are mutually exclusive anyway, allowing for slightly more efficient branching logic.

These optimizations are particularly effective for error-handling test cases (showing 2-18% improvements in the annotated tests) where the function exits early through validation checks. The improvements stem from reducing Python bytecode operations - fewer variable assignments, eliminated ternary operations, and more direct control flow paths. While the gains are modest, they compound in high-frequency model loading scenarios typical in ML workflows.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 6 Passed
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	🔘 None Found
📊 Tests Coverage	88.9%

🌀 Generated Regression Tests and Runtime

import pytest
from transformers.utils.backbone_utils import load_backbone


# --- Minimal stubs for testing ---
class AutoBackbone:
    # Used to simulate the backbone loading logic
    @staticmethod
    def from_config(config, **kwargs):
        # For testing, return a dict describing the call
        return {"method": "from_config", "config": config, "kwargs": kwargs}
    @staticmethod
    def from_pretrained(checkpoint, **kwargs):
        # For testing, return a dict describing the call
        return {"method": "from_pretrained", "checkpoint": checkpoint, "kwargs": kwargs}

class AutoConfig:
    @staticmethod
    def from_pretrained(checkpoint, **kwargs):
        # For testing, return a dict describing the call
        return {"config_from": checkpoint, "kwargs": kwargs}

# --- Helper config class for tests ---
class DummyConfig:
    """A simple config object whose attributes can be set in the constructor."""
    def __init__(
        self,
        backbone_config=None,
        use_timm_backbone=None,
        use_pretrained_backbone=None,
        backbone=None,
        backbone_kwargs=None
    ):
        self.backbone_config = backbone_config
        self.use_timm_backbone = use_timm_backbone
        self.use_pretrained_backbone = use_pretrained_backbone
        self.backbone = backbone
        self.backbone_kwargs = backbone_kwargs

# --- Unit tests ---

# ========== BASIC TEST CASES ==========








def test_error_backbone_kwargs_and_backbone_config():
    """Test error when both backbone_kwargs and backbone_config are set."""
    config = DummyConfig(backbone_config={"foo": "bar"}, backbone_kwargs={"baz": 123})
    with pytest.raises(ValueError, match="You can't specify both"):
        load_backbone(config) # 7.81μs -> 6.58μs (18.5% faster)

def test_error_backbone_config_and_checkpoint_and_pretrained():
    """Test error when backbone_config, backbone_checkpoint, and use_pretrained_backbone are all set."""
    config = DummyConfig(backbone_config={"foo": "bar"}, backbone="checkpoint", use_pretrained_backbone=True)
    with pytest.raises(ValueError, match="Cannot specify both config.backbone_config and config.backbone"):
        load_backbone(config) # 6.23μs -> 5.39μs (15.6% faster)

def test_error_timm_backbone_without_checkpoint():
    """Test error when use_timm_backbone is True but no backbone checkpoint is set."""
    config = DummyConfig(use_timm_backbone=True)
    with pytest.raises(ValueError, match="config.backbone must be set if use_timm_backbone is True"):
        load_backbone(config) # 5.43μs -> 5.30μs (2.32% faster)










#------------------------------------------------
import sys
import types

# imports
import pytest  # used for our unit tests
from transformers.utils.backbone_utils import \
    load_backbone  # --- End: function to test ---

# --- Begin: test scaffolding ---

# Dummy classes to simulate transformers' AutoBackbone and AutoConfig
class DummyBackbone:
    def __init__(self, config=None, checkpoint=None, from_pretrained=False, use_timm_backbone=None, use_pretrained_backbone=None, **kwargs):
        self.config = config
        self.checkpoint = checkpoint
        self.from_pretrained = from_pretrained
        self.use_timm_backbone = use_timm_backbone
        self.use_pretrained_backbone = use_pretrained_backbone
        self.kwargs = kwargs

    def __eq__(self, other):
        if not isinstance(other, DummyBackbone):
            return False
        return (
            self.config == other.config and
            self.checkpoint == other.checkpoint and
            self.from_pretrained == other.from_pretrained and
            self.use_timm_backbone == other.use_timm_backbone and
            self.use_pretrained_backbone == other.use_pretrained_backbone and
            self.kwargs == other.kwargs
        )

class DummyConfig:
    def __init__(self, **kwargs):
        for k, v in kwargs.items():
            setattr(self, k, v)

# --- End: test scaffolding ---

# --- Begin: unit tests ---

# 1. Basic Test Cases







def test_error_both_backbone_kwargs_and_backbone_config():
    # Should raise if both backbone_kwargs and backbone_config are set
    backbone_config = DummyConfig(foo=1)
    config = DummyConfig(backbone_kwargs={'foo': 'bar'}, backbone_config=backbone_config)
    with pytest.raises(ValueError, match="You can't specify both `backbone_kwargs` and `backbone_config`."):
        load_backbone(config) # 7.46μs -> 6.81μs (9.53% faster)

def test_error_both_backbone_config_and_checkpoint_and_use_pretrained_backbone():
    # Should raise if backbone_config, backbone, and use_pretrained_backbone are all set
    backbone_config = DummyConfig(foo=1)
    config = DummyConfig(backbone_config=backbone_config, backbone='ckpt', use_pretrained_backbone=True)
    with pytest.raises(ValueError, match="Cannot specify both config.backbone_config and config.backbone"):
        load_backbone(config) # 6.15μs -> 5.77μs (6.61% faster)

def test_error_use_timm_backbone_without_checkpoint():
    # Should raise if use_timm_backbone is True but backbone is not set
    config = DummyConfig(use_timm_backbone=True)
    with pytest.raises(ValueError, match="config.backbone must be set if use_timm_backbone is True"):
        load_backbone(config) # 6.00μs -> 5.47μs (9.50% faster)

To edit these changes git checkout codeflash/optimize-load_backbone-mhjso1ys and push.