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

bplusplus/yolov5detect/models/yolov5x.yaml

@@ -1,49 +0,0 @@
-# Ultralytics YOLOv5 🚀, AGPL-3.0 license
-
-# Parameters
-nc: 80 # number of classes
-depth_multiple: 1.33 # model depth multiple
-width_multiple: 1.25 # layer channel multiple
-anchors:
-  - [10, 13, 16, 30, 33, 23] # P3/8
-  - [30, 61, 62, 45, 59, 119] # P4/16
-  - [116, 90, 156, 198, 373, 326] # P5/32
-
-# YOLOv5 v6.0 backbone
-backbone:
-  # [from, number, module, args]
-  [
-    [-1, 1, Conv, [64, 6, 2, 2]], # 0-P1/2
-    [-1, 1, Conv, [128, 3, 2]], # 1-P2/4
-    [-1, 3, C3, [128]],
-    [-1, 1, Conv, [256, 3, 2]], # 3-P3/8
-    [-1, 6, C3, [256]],
-    [-1, 1, Conv, [512, 3, 2]], # 5-P4/16
-    [-1, 9, C3, [512]],
-    [-1, 1, Conv, [1024, 3, 2]], # 7-P5/32
-    [-1, 3, C3, [1024]],
-    [-1, 1, SPPF, [1024, 5]], # 9
-  ]
-
-# YOLOv5 v6.0 head
-head: [
-    [-1, 1, Conv, [512, 1, 1]],
-    [-1, 1, nn.Upsample, [None, 2, "nearest"]],
-    [[-1, 6], 1, Concat, [1]], # cat backbone P4
-    [-1, 3, C3, [512, False]], # 13
-
-    [-1, 1, Conv, [256, 1, 1]],
-    [-1, 1, nn.Upsample, [None, 2, "nearest"]],
-    [[-1, 4], 1, Concat, [1]], # cat backbone P3
-    [-1, 3, C3, [256, False]], # 17 (P3/8-small)
-
-    [-1, 1, Conv, [256, 3, 2]],
-    [[-1, 14], 1, Concat, [1]], # cat head P4
-    [-1, 3, C3, [512, False]], # 20 (P4/16-medium)
-
-    [-1, 1, Conv, [512, 3, 2]],
-    [[-1, 10], 1, Concat, [1]], # cat head P5
-    [-1, 3, C3, [1024, False]], # 23 (P5/32-large)
-
-    [[17, 20, 23], 1, Detect, [nc, anchors]], # Detect(P3, P4, P5)
-  ]

bplusplus/yolov5detect/utils/__init__.py

@@ -1,97 +0,0 @@
-# Ultralytics YOLOv5 🚀, AGPL-3.0 license
-"""utils/initialization."""
-
-import contextlib
-import platform
-import threading
-
-
-def emojis(str=""):
-    """Returns an emoji-safe version of a string, stripped of emojis on Windows platforms."""
-    return str.encode().decode("ascii", "ignore") if platform.system() == "Windows" else str
-
-
-class TryExcept(contextlib.ContextDecorator):
-    """A context manager and decorator for error handling that prints an optional message with emojis on exception."""
-
-    def __init__(self, msg=""):
-        """Initializes TryExcept with an optional message, used as a decorator or context manager for error handling."""
-        self.msg = msg
-
-    def __enter__(self):
-        """Enter the runtime context related to this object for error handling with an optional message."""
-        pass
-
-    def __exit__(self, exc_type, value, traceback):
-        """Context manager exit method that prints an error message with emojis if an exception occurred, always returns
-        True.
-        """
-        if value:
-            print(emojis(f"{self.msg}{': ' if self.msg else ''}{value}"))
-        return True
-
-
-def threaded(func):
-    """Decorator @threaded to run a function in a separate thread, returning the thread instance."""
-
-    def wrapper(*args, **kwargs):
-        """Runs the decorated function in a separate daemon thread and returns the thread instance."""
-        thread = threading.Thread(target=func, args=args, kwargs=kwargs, daemon=True)
-        thread.start()
-        return thread
-
-    return wrapper
-
-
-def join_threads(verbose=False):
-    """
-    Joins all daemon threads, optionally printing their names if verbose is True.
-
-    Example: atexit.register(lambda: join_threads())
-    """
-    main_thread = threading.current_thread()
-    for t in threading.enumerate():
-        if t is not main_thread:
-            if verbose:
-                print(f"Joining thread {t.name}")
-            t.join()
-
-
-def notebook_init(verbose=True):
-    """Initializes notebook environment by checking requirements, cleaning up, and displaying system info."""
-    print("Checking setup...")
-
-    import os
-    import shutil
-
-    from ultralytics.utils.checks import check_requirements
-
-    from utils.general import check_font, is_colab
-    from utils.torch_utils import select_device  # imports
-
-    check_font()
-
-    import psutil
-
-    if check_requirements("wandb", install=False):
-        os.system("pip uninstall -y wandb")  # eliminate unexpected account creation prompt with infinite hang
-    if is_colab():
-        shutil.rmtree("/content/sample_data", ignore_errors=True)  # remove colab /sample_data directory
-
-    # System info
-    display = None
-    if verbose:
-        gb = 1 << 30  # bytes to GiB (1024 ** 3)
-        ram = psutil.virtual_memory().total
-        total, used, free = shutil.disk_usage("/")
-        with contextlib.suppress(Exception):  # clear display if ipython is installed
-            from IPython import display
-
-            display.clear_output()
-        s = f"({os.cpu_count()} CPUs, {ram / gb:.1f} GB RAM, {(total - free) / gb:.1f}/{total / gb:.1f} GB disk)"
-    else:
-        s = ""
-
-    select_device(newline=False)
-    print(emojis(f"Setup complete ✅ {s}"))
-    return display

bplusplus/yolov5detect/utils/activations.py

@@ -1,134 +0,0 @@
-# Ultralytics YOLOv5 🚀, AGPL-3.0 license
-"""Activation functions."""
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-
-
-class SiLU(nn.Module):
-    """Applies the Sigmoid-weighted Linear Unit (SiLU) activation function, also known as Swish."""
-
-    @staticmethod
-    def forward(x):
-        """
-        Applies the Sigmoid-weighted Linear Unit (SiLU) activation function.
-
-        https://arxiv.org/pdf/1606.08415.pdf.
-        """
-        return x * torch.sigmoid(x)
-
-
-class Hardswish(nn.Module):
-    """Applies the Hardswish activation function, which is efficient for mobile and embedded devices."""
-
-    @staticmethod
-    def forward(x):
-        """
-        Applies the Hardswish activation function, compatible with TorchScript, CoreML, and ONNX.
-
-        Equivalent to x * F.hardsigmoid(x)
-        """
-        return x * F.hardtanh(x + 3, 0.0, 6.0) / 6.0  # for TorchScript, CoreML and ONNX
-
-
-class Mish(nn.Module):
-    """Mish activation https://github.com/digantamisra98/Mish."""
-
-    @staticmethod
-    def forward(x):
-        """Applies the Mish activation function, a smooth alternative to ReLU."""
-        return x * F.softplus(x).tanh()
-
-
-class MemoryEfficientMish(nn.Module):
-    """Efficiently applies the Mish activation function using custom autograd for reduced memory usage."""
-
-    class F(torch.autograd.Function):
-        """Implements a custom autograd function for memory-efficient Mish activation."""
-
-        @staticmethod
-        def forward(ctx, x):
-            """Applies the Mish activation function, a smooth ReLU alternative, to the input tensor `x`."""
-            ctx.save_for_backward(x)
-            return x.mul(torch.tanh(F.softplus(x)))  # x * tanh(ln(1 + exp(x)))
-
-        @staticmethod
-        def backward(ctx, grad_output):
-            """Computes the gradient of the Mish activation function with respect to input `x`."""
-            x = ctx.saved_tensors[0]
-            sx = torch.sigmoid(x)
-            fx = F.softplus(x).tanh()
-            return grad_output * (fx + x * sx * (1 - fx * fx))
-
-    def forward(self, x):
-        """Applies the Mish activation function to the input tensor `x`."""
-        return self.F.apply(x)
-
-
-class FReLU(nn.Module):
-    """FReLU activation https://arxiv.org/abs/2007.11824."""
-
-    def __init__(self, c1, k=3):  # ch_in, kernel
-        """Initializes FReLU activation with channel `c1` and kernel size `k`."""
-        super().__init__()
-        self.conv = nn.Conv2d(c1, c1, k, 1, 1, groups=c1, bias=False)
-        self.bn = nn.BatchNorm2d(c1)
-
-    def forward(self, x):
-        """
-        Applies FReLU activation with max operation between input and BN-convolved input.
-
-        https://arxiv.org/abs/2007.11824
-        """
-        return torch.max(x, self.bn(self.conv(x)))
-
-
-class AconC(nn.Module):
-    """
-    ACON activation (activate or not) function.
-
-    AconC: (p1*x-p2*x) * sigmoid(beta*(p1*x-p2*x)) + p2*x, beta is a learnable parameter
-    See "Activate or Not: Learning Customized Activation" https://arxiv.org/pdf/2009.04759.pdf.
-    """
-
-    def __init__(self, c1):
-        """Initializes AconC with learnable parameters p1, p2, and beta for channel-wise activation control."""
-        super().__init__()
-        self.p1 = nn.Parameter(torch.randn(1, c1, 1, 1))
-        self.p2 = nn.Parameter(torch.randn(1, c1, 1, 1))
-        self.beta = nn.Parameter(torch.ones(1, c1, 1, 1))
-
-    def forward(self, x):
-        """Applies AconC activation function with learnable parameters for channel-wise control on input tensor x."""
-        dpx = (self.p1 - self.p2) * x
-        return dpx * torch.sigmoid(self.beta * dpx) + self.p2 * x
-
-
-class MetaAconC(nn.Module):
-    """
-    ACON activation (activate or not) function.
-
-    AconC: (p1*x-p2*x) * sigmoid(beta*(p1*x-p2*x)) + p2*x, beta is a learnable parameter
-    See "Activate or Not: Learning Customized Activation" https://arxiv.org/pdf/2009.04759.pdf.
-    """
-
-    def __init__(self, c1, k=1, s=1, r=16):
-        """Initializes MetaAconC with params: channel_in (c1), kernel size (k=1), stride (s=1), reduction (r=16)."""
-        super().__init__()
-        c2 = max(r, c1 // r)
-        self.p1 = nn.Parameter(torch.randn(1, c1, 1, 1))
-        self.p2 = nn.Parameter(torch.randn(1, c1, 1, 1))
-        self.fc1 = nn.Conv2d(c1, c2, k, s, bias=True)
-        self.fc2 = nn.Conv2d(c2, c1, k, s, bias=True)
-        # self.bn1 = nn.BatchNorm2d(c2)
-        # self.bn2 = nn.BatchNorm2d(c1)
-
-    def forward(self, x):
-        """Applies a forward pass transforming input `x` using learnable parameters and sigmoid activation."""
-        y = x.mean(dim=2, keepdims=True).mean(dim=3, keepdims=True)
-        # batch-size 1 bug/instabilities https://github.com/ultralytics/yolov5/issues/2891
-        # beta = torch.sigmoid(self.bn2(self.fc2(self.bn1(self.fc1(y)))))  # bug/unstable
-        beta = torch.sigmoid(self.fc2(self.fc1(y)))  # bug patch BN layers removed
-        dpx = (self.p1 - self.p2) * x
-        return dpx * torch.sigmoid(beta * dpx) + self.p2 * x