Skip to content

Register now for

# Reference for `ultralytics/utils/autobatch.py`

Note

This file is available at https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/autobatch.py. If you spot a problem please help fix it by contributing a Pull Request 🛠️. Thank you 🙏!

## `` ultralytics.utils.autobatch.check_train_batch_size

    check_train_batch_size(
        model: Module,
        imgsz: int = 640,
        amp: bool = True,
        batch: int | float = -1,
        max_num_obj: int = 1,
    ) -> int

Compute optimal YOLO training batch size using the autobatch() function.

Parameters:

Name | Type | Description | Default
--- | --- | --- | ---
`model` | `Module` | YOLO model to check batch size for. | required
`imgsz` | `int` | Image size used for training. | `640`
`amp` | `bool` | Use automatic mixed precision if True. | `True`
`batch` | `int | float` | Fraction of GPU memory to use. If -1, use default. | `-1`
`max_num_obj` | `int` | The maximum number of objects from dataset. | `1`

Returns:

Type | Description
--- | ---
`int` | Optimal batch size computed using the autobatch() function.

Notes

If 0.0 < batch < 1.0, it's used as the fraction of GPU memory to use. Otherwise, a default fraction of 0.6 is used.

Source code in `ultralytics/utils/autobatch.py`

    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    def check_train_batch_size(
        model: torch.nn.Module,
        imgsz: int = 640,
        amp: bool = True,
        batch: int | float = -1,
        max_num_obj: int = 1,
    ) -> int:
        """
        Compute optimal YOLO training batch size using the autobatch() function.

        Args:
            model (torch.nn.Module): YOLO model to check batch size for.
            imgsz (int, optional): Image size used for training.
            amp (bool, optional): Use automatic mixed precision if True.
            batch (int | float, optional): Fraction of GPU memory to use. If -1, use default.
            max_num_obj (int, optional): The maximum number of objects from dataset.

        Returns:
            (int): Optimal batch size computed using the autobatch() function.

        Notes:
            If 0.0 < batch < 1.0, it's used as the fraction of GPU memory to use.
            Otherwise, a default fraction of 0.6 is used.
        """
        with autocast(enabled=amp):
            return autobatch(
                deepcopy(model).train(), imgsz, fraction=batch if 0.0 < batch < 1.0 else 0.6, max_num_obj=max_num_obj
            )

## `` ultralytics.utils.autobatch.autobatch

    autobatch(
        model: Module,
        imgsz: int = 640,
        fraction: float = 0.6,
        batch_size: int = DEFAULT_CFG.batch,
        max_num_obj: int = 1,
    ) -> int

Automatically estimate the best YOLO batch size to use a fraction of the available CUDA memory.

Parameters:

Name | Type | Description | Default
--- | --- | --- | ---
`model` | `Module` | YOLO model to compute batch size for. | required
`imgsz` | `int` | The image size used as input for the YOLO model. | `640`
`fraction` | `float` | The fraction of available CUDA memory to use. | `0.6`
`batch_size` | `int` | The default batch size to use if an error is detected. | `batch`
`max_num_obj` | `int` | The maximum number of objects from dataset. | `1`

Returns:

Type | Description
--- | ---
`int` | The optimal batch size.

Source code in `ultralytics/utils/autobatch.py`

     46
     47
     48
     49
     50
     51
     52
     53
     54
     55
     56
     57
     58
     59
     60
     61
     62
     63
     64
     65
     66
     67
     68
     69
     70
     71
     72
     73
     74
     75
     76
     77
     78
     79
     80
     81
     82
     83
     84
     85
     86
     87
     88
     89
     90
     91
     92
     93
     94
     95
     96
     97
     98
     99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    def autobatch(
        model: torch.nn.Module,
        imgsz: int = 640,
        fraction: float = 0.60,
        batch_size: int = DEFAULT_CFG.batch,
        max_num_obj: int = 1,
    ) -> int:
        """
        Automatically estimate the best YOLO batch size to use a fraction of the available CUDA memory.

        Args:
            model (torch.nn.Module): YOLO model to compute batch size for.
            imgsz (int, optional): The image size used as input for the YOLO model.
            fraction (float, optional): The fraction of available CUDA memory to use.
            batch_size (int, optional): The default batch size to use if an error is detected.
            max_num_obj (int, optional): The maximum number of objects from dataset.

        Returns:
            (int): The optimal batch size.
        """
        # Check device
        prefix = colorstr("AutoBatch: ")
        LOGGER.info(f"{prefix}Computing optimal batch size for imgsz={imgsz} at {fraction * 100}% CUDA memory utilization.")
        device = next(model.parameters()).device  # get model device
        if device.type in {"cpu", "mps"}:
            LOGGER.warning(f"{prefix}intended for CUDA devices, using default batch-size {batch_size}")
            return batch_size
        if torch.backends.cudnn.benchmark:
            LOGGER.warning(f"{prefix}Requires torch.backends.cudnn.benchmark=False, using default batch-size {batch_size}")
            return batch_size

        # Inspect CUDA memory
        gb = 1 << 30  # bytes to GiB (1024 ** 3)
        d = f"CUDA:{os.getenv('CUDA_VISIBLE_DEVICES', '0').strip()[0]}"  # 'CUDA:0'
        properties = torch.cuda.get_device_properties(device)  # device properties
        t = properties.total_memory / gb  # GiB total
        r = torch.cuda.memory_reserved(device) / gb  # GiB reserved
        a = torch.cuda.memory_allocated(device) / gb  # GiB allocated
        f = t - (r + a)  # GiB free
        LOGGER.info(f"{prefix}{d} ({properties.name}) {t:.2f}G total, {r:.2f}G reserved, {a:.2f}G allocated, {f:.2f}G free")

        # Profile batch sizes
        batch_sizes = [1, 2, 4, 8, 16] if t < 16 else [1, 2, 4, 8, 16, 32, 64]
        try:
            img = [torch.empty(b, 3, imgsz, imgsz) for b in batch_sizes]
            results = profile_ops(img, model, n=1, device=device, max_num_obj=max_num_obj)

            # Fit a solution
            xy = [
                [x, y[2]]
                for i, (x, y) in enumerate(zip(batch_sizes, results))
                if y  # valid result
                and isinstance(y[2], (int, float))  # is numeric
                and 0 < y[2] < t  # between 0 and GPU limit
                and (i == 0 or not results[i - 1] or y[2] > results[i - 1][2])  # first item or increasing memory
            ]
            fit_x, fit_y = zip(*xy) if xy else ([], [])
            p = np.polyfit(fit_x, fit_y, deg=1)  # first-degree polynomial fit in log space
            b = int((round(f * fraction) - p[1]) / p[0])  # y intercept (optimal batch size)
            if None in results:  # some sizes failed
                i = results.index(None)  # first fail index
                if b >= batch_sizes[i]:  # y intercept above failure point
                    b = batch_sizes[max(i - 1, 0)]  # select prior safe point
            if b < 1 or b > 1024:  # b outside of safe range
                LOGGER.warning(f"{prefix}batch={b} outside safe range, using default batch-size {batch_size}.")
                b = batch_size

            fraction = (np.polyval(p, b) + r + a) / t  # predicted fraction
            LOGGER.info(f"{prefix}Using batch-size {b} for {d} {t * fraction:.2f}G/{t:.2f}G ({fraction * 100:.0f}%) ✅")
            return b
        except Exception as e:
            LOGGER.warning(f"{prefix}error detected: {e},  using default batch-size {batch_size}.")
            return batch_size
        finally:
            torch.cuda.empty_cache()

📅 Created 1 year ago ✏️ Updated 1 year ago