segment-everything 0.1.0__py3-none-any.whl

segment_everything/vendored/object_detection/ultralytics/yolo/utils/autobatch.py

@@ -0,0 +1,108 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+"""
+Functions for estimating the best YOLO batch size to use a fraction of the available CUDA memory in PyTorch.
+"""
+
+from copy import deepcopy
+
+import numpy as np
+import torch
+
+from ..utils import DEFAULT_CFG, LOGGER, colorstr
+from ..utils.torch_utils import profile
+
+
+def check_train_batch_size(model, imgsz=640, amp=True):
+    """
+    Check YOLO training batch size using the autobatch() function.
+
+    Args:
+        model (torch.nn.Module): YOLO model to check batch size for.
+        imgsz (int): Image size used for training.
+        amp (bool): If True, use automatic mixed precision (AMP) for training.
+
+    Returns:
+        (int): Optimal batch size computed using the autobatch() function.
+    """
+
+    with torch.cuda.amp.autocast(amp):
+        return autobatch(
+            deepcopy(model).train(), imgsz
+        )  # compute optimal batch size
+
+
+def autobatch(model, imgsz=640, fraction=0.67, batch_size=DEFAULT_CFG.batch):
+    """
+    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. Defaults to 640.
+        fraction (float, optional): The fraction of available CUDA memory to use. Defaults to 0.67.
+        batch_size (int, optional): The default batch size to use if an error is detected. Defaults to 16.
+
+    Returns:
+        (int): The optimal batch size.
+    """
+
+    # Check device
+    prefix = colorstr("AutoBatch: ")
+    LOGGER.info(f"{prefix}Computing optimal batch size for imgsz={imgsz}")
+    device = next(model.parameters()).device  # get model device
+    if device.type == "cpu":
+        LOGGER.info(
+            f"{prefix}CUDA not detected, using default CPU batch-size {batch_size}"
+        )
+        return batch_size
+    if torch.backends.cudnn.benchmark:
+        LOGGER.info(
+            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 = str(device).upper()  # '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]
+    try:
+        img = [torch.empty(b, 3, imgsz, imgsz) for b in batch_sizes]
+        results = profile(img, model, n=3, device=device)
+
+        # Fit a solution
+        y = [x[2] for x in results if x]  # memory [2]
+        p = np.polyfit(
+            batch_sizes[: len(y)], y, deg=1
+        )  # first degree polynomial fit
+        b = int(
+            (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
+            b = batch_size
+            LOGGER.info(
+                f"{prefix}WARNING ⚠️ CUDA anomaly detected, using default batch-size {batch_size}."
+            )
+
+        fraction = (np.polyval(p, b) + r + a) / t  # actual fraction predicted
+        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}WARNING ⚠️ error detected: {e},  using default batch-size {batch_size}."
+        )
+        return batch_size

segment_everything/vendored/object_detection/ultralytics/yolo/utils/callbacks/__init__.py

@@ -0,0 +1,5 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+
+from .base import add_integration_callbacks, default_callbacks, get_default_callbacks
+
+__all__ = 'add_integration_callbacks', 'default_callbacks', 'get_default_callbacks'

segment_everything/vendored/object_detection/ultralytics/yolo/utils/callbacks/base.py

@@ -0,0 +1,212 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+"""
+Base callbacks
+"""
+
+from collections import defaultdict
+from copy import deepcopy
+
+# Trainer callbacks ----------------------------------------------------------------------------------------------------
+
+
+def on_pretrain_routine_start(trainer):
+    """Called before the pretraining routine starts."""
+    pass
+
+
+def on_pretrain_routine_end(trainer):
+    """Called after the pretraining routine ends."""
+    pass
+
+
+def on_train_start(trainer):
+    """Called when the training starts."""
+    pass
+
+
+def on_train_epoch_start(trainer):
+    """Called at the start of each training epoch."""
+    pass
+
+
+def on_train_batch_start(trainer):
+    """Called at the start of each training batch."""
+    pass
+
+
+def optimizer_step(trainer):
+    """Called when the optimizer takes a step."""
+    pass
+
+
+def on_before_zero_grad(trainer):
+    """Called before the gradients are set to zero."""
+    pass
+
+
+def on_train_batch_end(trainer):
+    """Called at the end of each training batch."""
+    pass
+
+
+def on_train_epoch_end(trainer):
+    """Called at the end of each training epoch."""
+    pass
+
+
+def on_fit_epoch_end(trainer):
+    """Called at the end of each fit epoch (train + val)."""
+    pass
+
+
+def on_model_save(trainer):
+    """Called when the model is saved."""
+    pass
+
+
+def on_train_end(trainer):
+    """Called when the training ends."""
+    pass
+
+
+def on_params_update(trainer):
+    """Called when the model parameters are updated."""
+    pass
+
+
+def teardown(trainer):
+    """Called during the teardown of the training process."""
+    pass
+
+
+# Validator callbacks --------------------------------------------------------------------------------------------------
+
+
+def on_val_start(validator):
+    """Called when the validation starts."""
+    pass
+
+
+def on_val_batch_start(validator):
+    """Called at the start of each validation batch."""
+    pass
+
+
+def on_val_batch_end(validator):
+    """Called at the end of each validation batch."""
+    pass
+
+
+def on_val_end(validator):
+    """Called when the validation ends."""
+    pass
+
+
+# Predictor callbacks --------------------------------------------------------------------------------------------------
+
+
+def on_predict_start(predictor):
+    """Called when the prediction starts."""
+    pass
+
+
+def on_predict_batch_start(predictor):
+    """Called at the start of each prediction batch."""
+    pass
+
+
+def on_predict_batch_end(predictor):
+    """Called at the end of each prediction batch."""
+    pass
+
+
+def on_predict_postprocess_end(predictor):
+    """Called after the post-processing of the prediction ends."""
+    pass
+
+
+def on_predict_end(predictor):
+    """Called when the prediction ends."""
+    pass
+
+
+# Exporter callbacks ---------------------------------------------------------------------------------------------------
+
+
+def on_export_start(exporter):
+    """Called when the model export starts."""
+    pass
+
+
+def on_export_end(exporter):
+    """Called when the model export ends."""
+    pass
+
+
+default_callbacks = {
+    # Run in trainer
+    'on_pretrain_routine_start': [on_pretrain_routine_start],
+    'on_pretrain_routine_end': [on_pretrain_routine_end],
+    'on_train_start': [on_train_start],
+    'on_train_epoch_start': [on_train_epoch_start],
+    'on_train_batch_start': [on_train_batch_start],
+    'optimizer_step': [optimizer_step],
+    'on_before_zero_grad': [on_before_zero_grad],
+    'on_train_batch_end': [on_train_batch_end],
+    'on_train_epoch_end': [on_train_epoch_end],
+    'on_fit_epoch_end': [on_fit_epoch_end],  # fit = train + val
+    'on_model_save': [on_model_save],
+    'on_train_end': [on_train_end],
+    'on_params_update': [on_params_update],
+    'teardown': [teardown],
+
+    # Run in validator
+    'on_val_start': [on_val_start],
+    'on_val_batch_start': [on_val_batch_start],
+    'on_val_batch_end': [on_val_batch_end],
+    'on_val_end': [on_val_end],
+
+    # Run in predictor
+    'on_predict_start': [on_predict_start],
+    'on_predict_batch_start': [on_predict_batch_start],
+    'on_predict_postprocess_end': [on_predict_postprocess_end],
+    'on_predict_batch_end': [on_predict_batch_end],
+    'on_predict_end': [on_predict_end],
+
+    # Run in exporter
+    'on_export_start': [on_export_start],
+    'on_export_end': [on_export_end]}
+
+
+def get_default_callbacks():
+    """
+    Return a copy of the default_callbacks dictionary with lists as default values.
+
+    Returns:
+        (defaultdict): A defaultdict with keys from default_callbacks and empty lists as default values.
+    """
+    return defaultdict(list, deepcopy(default_callbacks))
+
+
+def add_integration_callbacks(instance):
+    """
+    Add integration callbacks from various sources to the instance's callbacks.
+
+    Args:
+        instance (Trainer, Predictor, Validator, Exporter): An object with a 'callbacks' attribute that is a dictionary
+            of callback lists.
+    """
+    from .clearml import callbacks as clearml_cb
+    from .comet import callbacks as comet_cb
+    from .dvc import callbacks as dvc_cb
+    from .hub import callbacks as hub_cb
+    from .mlflow import callbacks as mlflow_cb
+    from .neptune import callbacks as neptune_cb
+    from .raytune import callbacks as tune_cb
+    from .tensorboard import callbacks as tensorboard_cb
+    from .wb import callbacks as wb_cb
+
+    for x in clearml_cb, comet_cb, hub_cb, mlflow_cb, neptune_cb, tune_cb, tensorboard_cb, wb_cb, dvc_cb:
+        for k, v in x.items():
+            if v not in instance.callbacks[k]:  # prevent duplicate callbacks addition
+                instance.callbacks[k].append(v)  # callback[name].append(func)