bplusplus 0.1.1__py3-none-any.whl → 1.1.0__py3-none-any.whl

bplusplus/yolov5detect/utils/autobatch.py

@@ -0,0 +1,70 @@
+# Ultralytics YOLOv5 🚀, AGPL-3.0 license
+"""Auto-batch utils."""
+
+from copy import deepcopy
+
+import numpy as np
+import torch
+
+from utils.general import LOGGER, colorstr
+from utils.torch_utils import profile
+
+
+def check_train_batch_size(model, imgsz=640, amp=True):
+    """Checks and computes optimal training batch size for YOLOv5 model, given image size and AMP setting."""
+    with torch.cuda.amp.autocast(amp):
+        return autobatch(deepcopy(model).train(), imgsz)  # compute optimal batch size
+
+
+def autobatch(model, imgsz=640, fraction=0.8, batch_size=16):
+    """Estimates optimal YOLOv5 batch size using `fraction` of CUDA memory."""
+    # Usage:
+    #     import torch
+    #     from utils.autobatch import autobatch
+    #     model = torch.hub.load('ultralytics/yolov5', 'yolov5s', autoshape=False)
+    #     print(autobatch(model))
+
+    # 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)
+    except Exception as e:
+        LOGGER.warning(f"{prefix}{e}")
+
+    # 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.warning(f"{prefix}WARNING ⚠️ CUDA anomaly detected, recommend restart environment and retry command.")
+
+    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

bplusplus/yolov5detect/utils/aws/mime.sh

@@ -0,0 +1,26 @@
+# AWS EC2 instance startup 'MIME' script https://aws.amazon.com/premiumsupport/knowledge-center/execute-user-data-ec2/
+# This script will run on every instance restart, not only on first start
+# --- DO NOT COPY ABOVE COMMENTS WHEN PASTING INTO USERDATA ---
+
+Content-Type: multipart/mixed; boundary="//"
+MIME-Version: 1.0
+
+--//
+Content-Type: text/cloud-config; charset="us-ascii"
+MIME-Version: 1.0
+Content-Transfer-Encoding: 7bit
+Content-Disposition: attachment; filename="cloud-config.txt"
+
+#cloud-config
+cloud_final_modules:
+- [scripts-user, always]
+
+--//
+Content-Type: text/x-shellscript; charset="us-ascii"
+MIME-Version: 1.0
+Content-Transfer-Encoding: 7bit
+Content-Disposition: attachment; filename="userdata.txt"
+
+#!/bin/bash
+# --- paste contents of userdata.sh here ---
+--//

bplusplus/yolov5detect/utils/aws/resume.py

@@ -0,0 +1,41 @@
+# Ultralytics YOLOv5 🚀, AGPL-3.0 license
+# Resume all interrupted trainings in yolov5/ dir including DDP trainings
+# Usage: $ python utils/aws/resume.py
+
+import os
+import sys
+from pathlib import Path
+
+import torch
+import yaml
+
+FILE = Path(__file__).resolve()
+ROOT = FILE.parents[2]  # YOLOv5 root directory
+if str(ROOT) not in sys.path:
+    sys.path.append(str(ROOT))  # add ROOT to PATH
+
+port = 0  # --master_port
+path = Path("").resolve()
+for last in path.rglob("*/**/last.pt"):
+    ckpt = torch.load(last)
+    if ckpt["optimizer"] is None:
+        continue
+
+    # Load opt.yaml
+    with open(last.parent.parent / "opt.yaml", errors="ignore") as f:
+        opt = yaml.safe_load(f)
+
+    # Get device count
+    d = opt["device"].split(",")  # devices
+    nd = len(d)  # number of devices
+    ddp = nd > 1 or (nd == 0 and torch.cuda.device_count() > 1)  # distributed data parallel
+
+    if ddp:  # multi-GPU
+        port += 1
+        cmd = f"python -m torch.distributed.run --nproc_per_node {nd} --master_port {port} train.py --resume {last}"
+    else:  # single-GPU
+        cmd = f"python train.py --resume {last}"
+
+    cmd += " > /dev/null 2>&1 &"  # redirect output to dev/null and run in daemon thread
+    print(cmd)
+    os.system(cmd)

bplusplus/yolov5detect/utils/aws/userdata.sh

@@ -0,0 +1,27 @@
+#!/bin/bash
+# AWS EC2 instance startup script https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/user-data.html
+# This script will run only once on first instance start (for a re-start script see mime.sh)
+# /home/ubuntu (ubuntu) or /home/ec2-user (amazon-linux) is working dir
+# Use >300 GB SSD
+
+cd home/ubuntu
+if [ ! -d yolov5 ]; then
+  echo "Running first-time script." # install dependencies, download COCO, pull Docker
+  git clone https://github.com/ultralytics/yolov5 -b master && sudo chmod -R 777 yolov5
+  cd yolov5
+  bash data/scripts/get_coco.sh && echo "COCO done." &
+  sudo docker pull ultralytics/yolov5:latest && echo "Docker done." &
+  python -m pip install --upgrade pip && pip install -r requirements.txt && python detect.py && echo "Requirements done." &
+  wait && echo "All tasks done." # finish background tasks
+else
+  echo "Running re-start script." # resume interrupted runs
+  i=0
+  list=$(sudo docker ps -qa) # container list i.e. $'one\ntwo\nthree\nfour'
+  while IFS= read -r id; do
+    ((i++))
+    echo "restarting container $i: $id"
+    sudo docker start $id
+    # sudo docker exec -it $id python train.py --resume # single-GPU
+    sudo docker exec -d $id python utils/aws/resume.py # multi-scenario
+  done <<<"$list"
+fi

bplusplus/yolov5detect/utils/callbacks.py

@@ -0,0 +1,72 @@
+# Ultralytics YOLOv5 🚀, AGPL-3.0 license
+"""Callback utils."""
+
+import threading
+
+
+class Callbacks:
+    """Handles all registered callbacks for YOLOv5 Hooks."""
+
+    def __init__(self):
+        """Initializes a Callbacks object to manage registered YOLOv5 training event hooks."""
+        self._callbacks = {
+            "on_pretrain_routine_start": [],
+            "on_pretrain_routine_end": [],
+            "on_train_start": [],
+            "on_train_epoch_start": [],
+            "on_train_batch_start": [],
+            "optimizer_step": [],
+            "on_before_zero_grad": [],
+            "on_train_batch_end": [],
+            "on_train_epoch_end": [],
+            "on_val_start": [],
+            "on_val_batch_start": [],
+            "on_val_image_end": [],
+            "on_val_batch_end": [],
+            "on_val_end": [],
+            "on_fit_epoch_end": [],  # fit = train + val
+            "on_model_save": [],
+            "on_train_end": [],
+            "on_params_update": [],
+            "teardown": [],
+        }
+        self.stop_training = False  # set True to interrupt training
+
+    def register_action(self, hook, name="", callback=None):
+        """
+        Register a new action to a callback hook.
+
+        Args:
+            hook: The callback hook name to register the action to
+            name: The name of the action for later reference
+            callback: The callback to fire
+        """
+        assert hook in self._callbacks, f"hook '{hook}' not found in callbacks {self._callbacks}"
+        assert callable(callback), f"callback '{callback}' is not callable"
+        self._callbacks[hook].append({"name": name, "callback": callback})
+
+    def get_registered_actions(self, hook=None):
+        """
+        Returns all the registered actions by callback hook.
+
+        Args:
+            hook: The name of the hook to check, defaults to all
+        """
+        return self._callbacks[hook] if hook else self._callbacks
+
+    def run(self, hook, *args, thread=False, **kwargs):
+        """
+        Loop through the registered actions and fire all callbacks on main thread.
+
+        Args:
+            hook: The name of the hook to check, defaults to all
+            args: Arguments to receive from YOLOv5
+            thread: (boolean) Run callbacks in daemon thread
+            kwargs: Keyword Arguments to receive from YOLOv5
+        """
+        assert hook in self._callbacks, f"hook '{hook}' not found in callbacks {self._callbacks}"
+        for logger in self._callbacks[hook]:
+            if thread:
+                threading.Thread(target=logger["callback"], args=args, kwargs=kwargs, daemon=True).start()
+            else:
+                logger["callback"](*args, **kwargs)