dgenerate-ultralytics-headless 8.3.186__py3-none-any.whl → 8.3.189__py3-none-any.whl

ultralytics/utils/torch_utils.py

@@ -250,68 +250,71 @@ def time_sync():
 
 
 def fuse_conv_and_bn(conv, bn):
-    """Fuse Conv2d() and BatchNorm2d() layers."""
-    fusedconv = (
-        nn.Conv2d(
-            conv.in_channels,
-            conv.out_channels,
-            kernel_size=conv.kernel_size,
-            stride=conv.stride,
-            padding=conv.padding,
-            dilation=conv.dilation,
-            groups=conv.groups,
-            bias=True,
-        )
-        .requires_grad_(False)
-        .to(conv.weight.device)
-    )
+    """
+    Fuse Conv2d and BatchNorm2d layers for inference optimization.
+
+    Args:
+        conv (nn.Conv2d): Convolutional layer to fuse.
+        bn (nn.BatchNorm2d): Batch normalization layer to fuse.
+
+    Returns:
+        (nn.Conv2d): The fused convolutional layer with gradients disabled.
 
-    # Prepare filters
+    Example:
+        >>> conv = nn.Conv2d(3, 16, 3)
+        >>> bn = nn.BatchNorm2d(16)
+        >>> fused_conv = fuse_conv_and_bn(conv, bn)
+    """
+    # Compute fused weights
     w_conv = conv.weight.view(conv.out_channels, -1)
     w_bn = torch.diag(bn.weight.div(torch.sqrt(bn.eps + bn.running_var)))
-    fusedconv.weight.copy_(torch.mm(w_bn, w_conv).view(fusedconv.weight.shape))
+    conv.weight.data = torch.mm(w_bn, w_conv).view(conv.weight.shape)
 
-    # Prepare spatial bias
-    b_conv = (
-        torch.zeros(conv.weight.shape[0], dtype=conv.weight.dtype, device=conv.weight.device)
-        if conv.bias is None
-        else conv.bias
-    )
+    # Compute fused bias
+    b_conv = torch.zeros(conv.out_channels, device=conv.weight.device) if conv.bias is None else conv.bias
     b_bn = bn.bias - bn.weight.mul(bn.running_mean).div(torch.sqrt(bn.running_var + bn.eps))
-    fusedconv.bias.copy_(torch.mm(w_bn, b_conv.reshape(-1, 1)).reshape(-1) + b_bn)
+    fused_bias = torch.mm(w_bn, b_conv.reshape(-1, 1)).reshape(-1) + b_bn
+
+    if conv.bias is None:
+        conv.register_parameter("bias", nn.Parameter(fused_bias))
+    else:
+        conv.bias.data = fused_bias
 
-    return fusedconv
+    return conv.requires_grad_(False)
 
 
 def fuse_deconv_and_bn(deconv, bn):
-    """Fuse ConvTranspose2d() and BatchNorm2d() layers."""
-    fuseddconv = (
-        nn.ConvTranspose2d(
-            deconv.in_channels,
-            deconv.out_channels,
-            kernel_size=deconv.kernel_size,
-            stride=deconv.stride,
-            padding=deconv.padding,
-            output_padding=deconv.output_padding,
-            dilation=deconv.dilation,
-            groups=deconv.groups,
-            bias=True,
-        )
-        .requires_grad_(False)
-        .to(deconv.weight.device)
-    )
+    """
+    Fuse ConvTranspose2d and BatchNorm2d layers for inference optimization.
 
-    # Prepare filters
+    Args:
+        deconv (nn.ConvTranspose2d): Transposed convolutional layer to fuse.
+        bn (nn.BatchNorm2d): Batch normalization layer to fuse.
+
+    Returns:
+        (nn.ConvTranspose2d): The fused transposed convolutional layer with gradients disabled.
+
+    Example:
+        >>> deconv = nn.ConvTranspose2d(16, 3, 3)
+        >>> bn = nn.BatchNorm2d(3)
+        >>> fused_deconv = fuse_deconv_and_bn(deconv, bn)
+    """
+    # Compute fused weights
     w_deconv = deconv.weight.view(deconv.out_channels, -1)
     w_bn = torch.diag(bn.weight.div(torch.sqrt(bn.eps + bn.running_var)))
-    fuseddconv.weight.copy_(torch.mm(w_bn, w_deconv).view(fuseddconv.weight.shape))
+    deconv.weight.data = torch.mm(w_bn, w_deconv).view(deconv.weight.shape)
 
-    # Prepare spatial bias
-    b_conv = torch.zeros(deconv.weight.shape[1], device=deconv.weight.device) if deconv.bias is None else deconv.bias
+    # Compute fused bias
+    b_conv = torch.zeros(deconv.out_channels, device=deconv.weight.device) if deconv.bias is None else deconv.bias
     b_bn = bn.bias - bn.weight.mul(bn.running_mean).div(torch.sqrt(bn.running_var + bn.eps))
-    fuseddconv.bias.copy_(torch.mm(w_bn, b_conv.reshape(-1, 1)).reshape(-1) + b_bn)
+    fused_bias = torch.mm(w_bn, b_conv.reshape(-1, 1)).reshape(-1) + b_bn
+
+    if deconv.bias is None:
+        deconv.register_parameter("bias", nn.Parameter(fused_bias))
+    else:
+        deconv.bias.data = fused_bias
 
-    return fuseddconv
+    return deconv.requires_grad_(False)
 
 
 def model_info(model, detailed=False, verbose=True, imgsz=640):

ultralytics/utils/tqdm.py

@@ -10,7 +10,7 @@ from typing import IO, Any
 
 
 @lru_cache(maxsize=1)
-def is_noninteractive_console():
+def is_noninteractive_console() -> bool:
     """Check for known non-interactive console environments."""
     return "GITHUB_ACTIONS" in os.environ or "RUNPOD_POD_ID" in os.environ
 
@@ -128,7 +128,7 @@ class TQDM:
 
         self.iterable = iterable
         self.desc = desc or ""
-        self.total = total if total is not None else (len(iterable) if hasattr(iterable, "__len__") else None)
+        self.total = total or (len(iterable) if hasattr(iterable, "__len__") else None) or None  # prevent total=0
         self.disable = disable
         self.unit = unit
         self.unit_scale = unit_scale
@@ -158,7 +158,7 @@ class TQDM:
         if not self.disable and self.total is not None and not self.noninteractive:
             self._display()
 
-    def _format_rate(self, rate):
+    def _format_rate(self, rate: float) -> str:
         """Format rate with proper units and reasonable precision."""
         if rate <= 0:
             return ""
@@ -180,7 +180,7 @@ class TQDM:
         precision = ".1f" if rate >= 1 else ".2f"
         return f"{rate:{precision}}{self.unit}/s"
 
-    def _format_num(self, num):
+    def _format_num(self, num: int) -> str:
         """Format number with optional unit scaling."""
         if not self.unit_scale or self.unit not in ("B", "bytes"):
             return str(num)
@@ -191,7 +191,7 @@ class TQDM:
             num /= self.unit_divisor
         return f"{num:.1f}PB"
 
-    def _format_time(self, seconds):
+    def _format_time(self, seconds: float) -> str:
         """Format time duration."""
         if seconds < 60:
             return f"{seconds:.1f}s"
@@ -201,7 +201,7 @@ class TQDM:
             h, m = int(seconds // 3600), int((seconds % 3600) // 60)
             return f"{h}:{m:02d}:{seconds % 60:02.0f}"
 
-    def _generate_bar(self, width=12):
+    def _generate_bar(self, width: int = 12) -> str:
         """Generate progress bar."""
         if self.total is None:
             return "━" * width if self.closed else "─" * width
@@ -213,7 +213,7 @@ class TQDM:
             bar = bar[:filled] + "╸" + bar[filled + 1 :]
         return bar
 
-    def _should_update(self, dt, dn):
+    def _should_update(self, dt: float, dn: int) -> bool:
         """Check if display should update."""
         if self.noninteractive:
             return False
@@ -223,7 +223,7 @@ class TQDM:
 
         return dt >= self.mininterval
 
-    def _display(self, final=False):
+    def _display(self, final: bool = False) -> None:
         """Display progress bar."""
         if self.disable or (self.closed and not final):
             return
@@ -296,26 +296,26 @@ class TQDM:
         except Exception:
             pass
 
-    def update(self, n=1):
+    def update(self, n: int = 1) -> None:
         """Update progress by n steps."""
         if not self.disable and not self.closed:
             self.n += n
             self._display()
 
-    def set_description(self, desc):
+    def set_description(self, desc: str | None) -> None:
         """Set description."""
         self.desc = desc or ""
         if not self.disable:
             self._display()
 
-    def set_postfix(self, **kwargs):
+    def set_postfix(self, **kwargs: Any) -> None:
         """Set postfix (appends to description)."""
         if kwargs:
             postfix = ", ".join(f"{k}={v}" for k, v in kwargs.items())
             base_desc = self.desc.split(" | ")[0] if " | " in self.desc else self.desc
             self.set_description(f"{base_desc} | {postfix}")
 
-    def close(self):
+    def close(self) -> None:
         """Close progress bar."""
         if self.closed:
             return
@@ -339,15 +339,15 @@ class TQDM:
             except Exception:
                 pass
 
-    def __enter__(self):
+    def __enter__(self) -> TQDM:
         """Enter context manager."""
         return self
 
-    def __exit__(self, *args):
+    def __exit__(self, *args: Any) -> None:
         """Exit context manager and close progress bar."""
         self.close()
 
-    def __iter__(self):
+    def __iter__(self) -> Any:
         """Iterate over the wrapped iterable with progress updates."""
         if self.iterable is None:
             raise TypeError("'NoneType' object is not iterable")
@@ -359,19 +359,19 @@ class TQDM:
         finally:
             self.close()
 
-    def __del__(self):
+    def __del__(self) -> None:
         """Destructor to ensure cleanup."""
         try:
             self.close()
         except Exception:
             pass
 
-    def refresh(self):
+    def refresh(self) -> None:
         """Refresh display."""
         if not self.disable:
             self._display()
 
-    def clear(self):
+    def clear(self) -> None:
         """Clear progress bar."""
         if not self.disable:
             try:
@@ -381,7 +381,7 @@ class TQDM:
                 pass
 
     @staticmethod
-    def write(s, file=None, end="\n"):
+    def write(s: str, file: IO[str] | None = None, end: str = "\n") -> None:
         """Static method to write without breaking progress bar."""
         file = file or sys.stdout
         try:
@@ -394,14 +394,11 @@ class TQDM:
 if __name__ == "__main__":
     import time
 
-    # Example 1: Basic usage with known total
     print("1. Basic progress bar with known total:")
-    for i in TQDM(range(20), desc="Known total"):
+    for i in TQDM(range(0), desc="Known total"):
         time.sleep(0.05)
-    print()
 
-    # Example 2: Manual updates with known total
-    print("2. Manual updates with known total:")
+    print("\n2. Manual updates with known total:")
     pbar = TQDM(total=30, desc="Manual updates", unit="files")
     for i in range(30):
         time.sleep(0.03)
@@ -409,10 +406,8 @@ if __name__ == "__main__":
         if i % 10 == 9:
             pbar.set_description(f"Processing batch {i // 10 + 1}")
     pbar.close()
-    print()
 
-    # Example 3: Unknown total - this was the problematic case
-    print("3. Progress bar with unknown total:")
+    print("\n3. Progress bar with unknown total:")
     pbar = TQDM(desc="Unknown total", unit="items")
     for i in range(25):
         time.sleep(0.08)
@@ -420,18 +415,14 @@ if __name__ == "__main__":
         if i % 5 == 4:
             pbar.set_postfix(processed=i + 1, status="OK")
     pbar.close()
-    print()
 
-    # Example 4: Context manager with unknown total
-    print("4. Context manager with unknown total:")
+    print("\n4. Context manager with unknown total:")
     with TQDM(desc="Processing stream", unit="B", unit_scale=True, unit_divisor=1024) as pbar:
         for i in range(30):
             time.sleep(0.1)
             pbar.update(1024 * 1024 * i)  # Simulate processing MB of data
-    print()
 
-    # Example 5: Generator with unknown length
-    print("5. Iterator with unknown length:")
+    print("\n5. Iterator with unknown length:")
 
     def data_stream():
         """Simulate a data stream of unknown length."""
@@ -442,10 +433,8 @@ if __name__ == "__main__":
 
     for chunk in TQDM(data_stream(), desc="Stream processing", unit="chunks"):
         time.sleep(0.1)
-    print()
 
-    # Example 6: File-like processing simulation
-    print("6. File processing simulation (unknown size):")
+    print("\n6. File processing simulation (unknown size):")
 
     def process_files():
         """Simulate processing files of unknown count."""
@@ -459,4 +448,3 @@ if __name__ == "__main__":
         pbar.update(1)
         pbar.set_description(f"Processing {filename}")
     pbar.close()
-    print()