lucid-dl 2.11.2__py3-none-any.whl → 2.11.3__py3-none-any.whl

lucid/models/imgclf/crossvit.py

@@ -79,7 +79,7 @@ class _PatchEmbed(nn.Module):
                 f"Input image size {(H, W)} does not match with {self.img_size}."
             )
 
-        x = self.proj(x).flatten(axis=2).swapaxes(1, 2)
+        x = self.proj(x).flatten(start_axis=2).swapaxes(1, 2)
         return x
 
 

lucid/models/imgclf/efficientformer.py

@@ -80,7 +80,7 @@ class _Attention(nn.Module):
         y, x = lucid.meshgrid(
             lucid.arange(resolution[0]), lucid.arange(resolution[1]), indexing="ij"
         )
-        pos = lucid.stack([y, x]).flatten(axis=1)
+        pos = lucid.stack([y, x]).flatten(start_axis=1)
         rel_pos = lucid.abs(pos[..., :, None] - pos[..., None, :])
         rel_pos = (rel_pos[0] * resolution[1]) + rel_pos[1]
 
@@ -159,7 +159,7 @@ class _Downsample(nn.Module):
 
 class _Flatten(nn.Module):
     def forward(self, x: Tensor) -> Tensor:
-        x = x.flatten(axis=2).swapaxes(1, 2)
+        x = x.flatten(start_axis=2).swapaxes(1, 2)
         return x
 
 

lucid/models/imgclf/maxvit.py

@@ -216,7 +216,7 @@ def _grid_reverse(
 
 def _get_relative_position_index(win_h: int, win_w: int) -> Tensor:
     coords = lucid.stack(lucid.meshgrid(lucid.arange(win_h), lucid.arange(win_w)))
-    coords_flatten = lucid.flatten(coords, axis=1)
+    coords_flatten = lucid.flatten(coords, start_axis=1)
 
     relative_coords = coords_flatten[:, :, None] - coords_flatten[:, None, :]
     relative_coords = relative_coords.transpose((1, 2, 0))

lucid/models/imgclf/pvt.py

@@ -328,7 +328,7 @@ class _DWConv(nn.Module):
         B, _, C = x.shape
         x = x.swapaxes(1, 2).reshape(B, C, H, W)
         x = self.dwconv(x)
-        x = x.flatten(axis=2).swapaxes(1, 2)
+        x = x.flatten(start_axis=2).swapaxes(1, 2)
 
         return x
 
@@ -548,7 +548,7 @@ class _OverlapPatchEmbed(nn.Module):
     def forward(self, x: Tensor) -> tuple[Tensor, int, int]:
         x = self.proj(x)
         H, W = x.shape[2:]
-        x = x.flatten(axis=2).swapaxes(1, 2)
+        x = x.flatten(start_axis=2).swapaxes(1, 2)
         x = self.norm(x)
 
         return x, H, W

lucid/models/imggen/vae.py

@@ -51,7 +51,7 @@ class VAE(nn.Module):
         h = x
         for encoder in self.encoders:
             h = encoder(h)
-            mu, logvar = lucid.split(h, 2, axis=1)
+            mu, logvar = lucid.chunk(h, 2, axis=1)
             z = self.reparameterize(mu, logvar)
 
             mus.append(mu)

lucid/models/objdet/efficientdet.py

@@ -82,23 +82,37 @@ class _BiFPN(nn.Module):
     def _norm_weight(self, weight: Tensor) -> Tensor:
         return weight / (weight.sum(axis=0) + self.eps)
 
+    @staticmethod
+    def _resize_like(x: Tensor, ref: Tensor) -> Tensor:
+        if x.shape[2:] == ref.shape[2:]:
+            return x
+        return F.interpolate(x, size=ref.shape[2:], mode="nearest")
+
     def _forward_up(self, feats: tuple[Tensor]) -> tuple[Tensor]:
         p3_in, p4_in, p5_in, p6_in, p7_in = feats
 
         w1_p6_up = self._norm_weight(self.acts["6_w1"](self.weights["6_w1"]))
-        p6_up_in = w1_p6_up[0] * p6_in + w1_p6_up[1] * self.ups["6"](p7_in)
+        p6_up_in = w1_p6_up[0] * p6_in + w1_p6_up[1] * self._resize_like(
+            self.ups["6"](p7_in), p6_in
+        )
         p6_up = self.convs["6_up"](p6_up_in)
 
         w1_p5_up = self._norm_weight(self.acts["5_w1"](self.weights["5_w1"]))
-        p5_up_in = w1_p5_up[0] * p5_in + w1_p5_up[1] * self.ups["5"](p6_up)
+        p5_up_in = w1_p5_up[0] * p5_in + w1_p5_up[1] * self._resize_like(
+            self.ups["5"](p6_up), p5_in
+        )
         p5_up = self.convs["5_up"](p5_up_in)
 
         w1_p4_up = self._norm_weight(self.acts["4_w1"](self.weights["4_w1"]))
-        p4_up_in = w1_p4_up[0] * p4_in + w1_p4_up[1] * self.ups["4"](p5_up)
+        p4_up_in = w1_p4_up[0] * p4_in + w1_p4_up[1] * self._resize_like(
+            self.ups["4"](p5_up), p4_in
+        )
         p4_up = self.convs["4_up"](p4_up_in)
 
         w1_p3_up = self._norm_weight(self.acts["3_w1"](self.weights["3_w1"]))
-        p3_up_in = w1_p3_up[0] * p3_in + w1_p3_up[1] * self.ups["3"](p4_up)
+        p3_up_in = w1_p3_up[0] * p3_in + w1_p3_up[1] * self._resize_like(
+            self.ups["3"](p4_up), p3_in
+        )
         p3_out = self.convs["3_up"](p3_up_in)
 
         return p3_out, p4_up, p5_up, p6_up
@@ -113,7 +127,7 @@ class _BiFPN(nn.Module):
         p4_down_in = (
             w2_p4_down[0] * p4_in
             + w2_p4_down[1] * p4_up
-            + w2_p4_down[2] * self.downs["4"](p3_out)
+            + w2_p4_down[2] * self._resize_like(self.downs["4"](p3_out), p4_in)
         )
         p4_out = self.convs["4_down"](p4_down_in)
 
@@ -121,7 +135,7 @@ class _BiFPN(nn.Module):
         p5_down_in = (
             w2_p5_down[0] * p5_in
             + w2_p5_down[1] * p5_up
-            + w2_p5_down[2] * self.downs["5"](p4_out)
+            + w2_p5_down[2] * self._resize_like(self.downs["5"](p4_out), p5_in)
         )
         p5_out = self.convs["5_down"](p5_down_in)
 
@@ -129,12 +143,14 @@ class _BiFPN(nn.Module):
         p6_down_in = (
             w2_p6_down[0] * p6_in
             + w2_p6_down[1] * p6_up
-            + w2_p6_down[2] * self.downs["6"](p5_out)
+            + w2_p6_down[2] * self._resize_like(self.downs["6"](p5_out), p6_in)
         )
         p6_out = self.convs["6_down"](p6_down_in)
 
         w2_p7_down = self._norm_weight(self.acts["7_w2"](self.weights["7_w2"]))
-        p7_down_in = w2_p7_down[0] * p7_in + w2_p7_down[1] * self.downs["7"](p6_out)
+        p7_down_in = w2_p7_down[0] * p7_in + w2_p7_down[1] * self._resize_like(
+            self.downs["7"](p6_out), p7_in
+        )
         p7_out = self.convs["7_down"](p7_down_in)
 
         return p3_out, p4_out, p5_out, p6_out, p7_out

lucid/models/objdet/rcnn.py

@@ -120,7 +120,7 @@ class RCNN(nn.Module):
 
         if isinstance(feats, (tuple, list)):
             feats = feats[-1]
-        feats = feats.flatten(axis=1)
+        feats = feats.flatten(start_axis=1)
 
         cls_scores = self.svm(feats)
         bbox_deltas = self.bbox_reg(feats)

lucid/models/objdet/util.py

@@ -283,6 +283,11 @@ class SelectiveSearch(nn.Module):
 
 
 def iou(boxes_a: Tensor, boxes_b: Tensor) -> Tensor:
+    if boxes_a.ndim == 1:
+        boxes_a = boxes_a.unsqueeze(0)
+    if boxes_b.ndim == 1:
+        boxes_b = boxes_b.unsqueeze(0)
+
     x1a, y1a, x2a, y2a = boxes_a.unbind(axis=1)
     x1b, y1b, x2b, y2b = boxes_b.unbind(axis=1)
 

lucid/nn/module.py

@@ -29,8 +29,25 @@ __all__ = [
     "set_state_dict_pass_attr",
 ]
 
-_ForwardHookType = Callable[["Module", tuple[Tensor], tuple[Tensor]], None]
-_BackwardHookType = Callable[[Tensor, _NumPyArray], None]
+
+_ForwardPreHook = Callable[["Module", tuple[Any, ...]], tuple[Any, ...] | None]
+_ForwardPreHookKwargs = Callable[
+    ["Module", tuple[Any, ...], dict[str, Any]],
+    tuple[tuple[Any, ...], dict[str, Any]] | None,
+]
+_ForwardHook = Callable[["Module", tuple[Any, ...], Any], Any | None]
+_ForwardHookKwargs = Callable[
+    ["Module", tuple[Any, ...], dict[str, Any], Any], Any | None
+]
+
+_BackwardHook = Callable[[Tensor, _NumPyArray], None]
+_FullBackwardPreHook = Callable[
+    ["Module", tuple[_NumPyArray | None, ...]], tuple[_NumPyArray | None, ...] | None
+]
+_FullBackwardHook = Callable[
+    ["Module", tuple[_NumPyArray | None, ...], tuple[_NumPyArray | None, ...]],
+    tuple[_NumPyArray | None, ...] | None,
+]
 
 
 class Module:
@@ -49,8 +66,13 @@ class Module:
         self.training = True
         self.device: _DeviceType = "cpu"
 
-        self._forward_hooks: list[_ForwardHookType] = []
-        self._backward_hooks: list[_BackwardHookType] = []
+        self._forward_pre_hooks: list[
+            tuple[_ForwardPreHook | _ForwardPreHookKwargs, bool]
+        ] = []
+        self._forward_hooks: list[tuple[_ForwardHook | _ForwardHookKwargs, bool]] = []
+        self._backward_hooks: list[_BackwardHook] = []
+        self._full_backward_pre_hooks: list[_FullBackwardPreHook] = []
+        self._full_backward_hooks: list[_FullBackwardHook] = []
 
         self._state_dict_pass_attr = set()
 
@@ -106,14 +128,33 @@ class Module:
 
         self.__setattr__(name, buffer)
 
-    def register_forward_hook(self, hook: _ForwardHookType) -> Callable:
-        self._forward_hooks.append(hook)
-        return lambda: self._forward_hooks.remove(hook)
-
-    def register_backward_hook(self, hook: _BackwardHookType) -> Callable:
+    def register_forward_pre_hook(
+        self,
+        hook: _ForwardPreHook | _ForwardPreHookKwargs,
+        *,
+        with_kwargs: bool = False,
+    ) -> Callable:
+        self._forward_pre_hooks.append((hook, with_kwargs))
+        return lambda: self._forward_pre_hooks.remove((hook, with_kwargs))
+
+    def register_forward_hook(
+        self, hook: _ForwardHook | _ForwardHookKwargs, *, with_kwargs: bool = False
+    ) -> Callable:
+        self._forward_hooks.append((hook, with_kwargs))
+        return lambda: self._forward_hooks.remove((hook, with_kwargs))
+
+    def register_backward_hook(self, hook: _BackwardHook) -> Callable:
         self._backward_hooks.append(hook)
         return lambda: self._backward_hooks.remove(hook)
 
+    def register_full_backward_pre_hook(self, hook: _FullBackwardPreHook) -> Callable:
+        self._full_backward_pre_hooks.append(hook)
+        return lambda: self._full_backward_pre_hooks.remove(hook)
+
+    def register_full_backward_hook(self, hook: _FullBackwardHook) -> Callable:
+        self._full_backward_hooks.append(hook)
+        return lambda: self._full_backward_hooks.remove(hook)
+
     def reset_parameters(self) -> None:
         for param in self.parameters():
             param.zero()
@@ -237,14 +278,68 @@ class Module:
                 raise KeyError(f"Unexpected key '{key}' in state_dict.")
 
     def __call__(self, *args: Any, **kwargs: Any) -> Tensor | tuple[Tensor, ...]:
+        for hook, with_kwargs in self._forward_pre_hooks:
+            if with_kwargs:
+                result = hook(self, args, kwargs)
+                if result is not None:
+                    args, kwargs = result
+            else:
+                result = hook(self, args)
+                if result is not None:
+                    args = result
+
         output = self.forward(*args, **kwargs)
-        for hook in self._forward_hooks:
-            hook(self, args, output)
+
+        for hook, with_kwargs in self._forward_hooks:
+            if with_kwargs:
+                result = hook(self, args, kwargs, output)
+            else:
+                result = hook(self, args, output)
+            if result is not None:
+                output = result
 
         if isinstance(output, Tensor) and self._backward_hooks:
             for hook in self._backward_hooks:
                 output.register_hook(hook)
 
+        if self._full_backward_pre_hooks or self._full_backward_hooks:
+            outputs = output if isinstance(output, tuple) else (output,)
+            output_tensors = [out for out in outputs if isinstance(out, Tensor)]
+
+            if output_tensors:
+                grad_outputs: list[_NumPyArray | None] = [None] * len(output_tensors)
+                called = False
+
+                def _call_full_backward_hooks() -> None:
+                    nonlocal called, grad_outputs
+                    if called:
+                        return
+                    called = True
+
+                    grad_output_tuple = tuple(grad_outputs)
+                    for hook in self._full_backward_pre_hooks:
+                        result = hook(self, grad_output_tuple)
+                        if result is not None:
+                            grad_output_tuple = result
+
+                    grad_input_tuple = tuple(
+                        arg.grad if isinstance(arg, Tensor) else None for arg in args
+                    )
+                    for hook in self._full_backward_hooks:
+                        hook(self, grad_input_tuple, grad_output_tuple)
+
+                for idx, out in enumerate(output_tensors):
+
+                    def _make_hook(index: int) -> Callable:
+                        def _hook(_, grad: _NumPyArray) -> None:
+                            grad_outputs[index] = grad
+                            if all(g is not None for g in grad_outputs):
+                                _call_full_backward_hooks()
+
+                        return _hook
+
+                    out.register_hook(_make_hook(idx))
+
         return output
 
     def __repr__(self) -> str:

lucid/visual/__init__.py

@@ -1 +1,2 @@
 from .graph import *
+from .mermaid import *

lucid/visual/graph.py

@@ -1,4 +1,6 @@
 from typing import Union
+from warnings import deprecated
+
 import networkx as nx
 import matplotlib.pyplot as plt
 
@@ -9,6 +11,7 @@ from lucid._tensor import Tensor
 __all__ = ["draw_tensor_graph"]
 
 
+@deprecated("This feature will be re-written with Mermaid in future relases.")
 def draw_tensor_graph(
     tensor: Tensor,
     horizontal: bool = False,

lucid/visual/mermaid.py

@@ -0,0 +1,818 @@
+from dataclasses import dataclass
+import json
+from typing import Iterable, Literal
+
+import lucid
+import lucid.nn as nn
+
+from lucid._tensor import Tensor
+from lucid.types import _ShapeLike
+
+
+__all__ = ["build_mermaid_chart"]
+
+
+_NN_MODULES_PREFIX = "lucid.nn.modules."
+
+
+# fmt: off
+_BUILTIN_SUBPACKAGE_STYLE: dict[str, tuple[str, str]] = {
+    "conv":         ("#ffe8e8", "#c53030"),
+    "norm":         ("#e6fffa", "#2c7a7b"),
+    "activation":   ("#faf5ff", "#6b46c1"),
+    "linear":       ("#ebf8ff", "#2b6cb0"),
+    "pool":         ("#fefcbf", "#b7791f"),
+    "drop":         ("#edf2f7", "#4a5568"),
+    "transformer":  ("#e2e8f0", "#334155"),
+    "attention":    ("#f0fff4", "#2f855a"),
+    "vision":       ("#fdf2f8", "#b83280"),
+    "rnn":          ("#f0f9ff", "#0284c7"),
+    "sparse":       ("#f1f5f9", "#475569"),
+    "loss":         ("#fffbeb", "#d97706"),
+    "einops":       ("#ecfccb", "#65a30d"),
+}
+# fmt: on
+
+
+@dataclass
+class _ModuleNode:
+    module: nn.Module
+    name: str
+    depth: int
+    children: list["_ModuleNode"]
+    group: list[nn.Module] | None = None
+
+    @property
+    def count(self) -> int:
+        return 1 if self.group is None else len(self.group)
+
+    def iter_modules(self) -> Iterable[nn.Module]:
+        if self.group is None:
+            yield self.module
+            return
+        yield from self.group
+
+
+def _flatten_tensors(obj: object) -> list[Tensor]:
+    tensors: list[Tensor] = []
+
+    if isinstance(obj, Tensor):
+        tensors.append(obj)
+    elif isinstance(obj, (list, tuple)):
+        for item in obj:
+            tensors.extend(_flatten_tensors(item))
+    elif isinstance(obj, dict):
+        for item in obj.values():
+            tensors.extend(_flatten_tensors(item))
+
+    return tensors
+
+
+def _build_tree(
+    module: nn.Module,
+    depth: int,
+    max_depth: int,
+    name: str = "",
+    *,
+    collapse_repeats: bool = False,
+    repeat_min: int = 3,
+    hide_subpackages: set[str] | None = None,
+    hide_module_names: set[str] | None = None,
+) -> _ModuleNode:
+    children: list[_ModuleNode] = []
+    if depth < max_depth:
+        for child_name, child in module._modules.items():
+            path = f"{name}.{child_name}" if name else child_name
+
+            node = _build_tree(
+                child,
+                depth + 1,
+                max_depth,
+                path,
+                collapse_repeats=collapse_repeats,
+                repeat_min=repeat_min,
+                hide_subpackages=hide_subpackages,
+                hide_module_names=hide_module_names,
+            )
+
+            child_cls_name = type(child).__name__
+            child_mod_path = type(child).__module__
+            child_subpkg = None
+
+            if child_mod_path.startswith(_NN_MODULES_PREFIX):
+                rest = child_mod_path[len(_NN_MODULES_PREFIX) :]
+                child_subpkg = rest.split(".", 1)[0] if rest else None
+
+            excluded = False
+            if hide_module_names and child_cls_name in hide_module_names:
+                excluded = True
+            if hide_subpackages and child_subpkg and child_subpkg in hide_subpackages:
+                excluded = True
+
+            if excluded:
+                children.extend(node.children)
+            else:
+                children.append(node)
+
+    if collapse_repeats and children:
+        children = _collapse_repeated_children(children, repeat_min=repeat_min)
+
+    return _ModuleNode(module=module, name=name, depth=depth, children=children)
+
+
+def _module_label(module: nn.Module, show_params: bool) -> str:
+    class_name = getattr(module, "_alt_name", "") or type(module).__name__
+    if show_params:
+        return f"{class_name} ({module.parameter_size:,} params)"
+
+    return class_name
+
+
+def _builtin_subpackage_key(module: nn.Module) -> str | None:
+    mod_path = type(module).__module__
+    if not mod_path.startswith(_NN_MODULES_PREFIX):
+        return None
+
+    rest = mod_path[len(_NN_MODULES_PREFIX) :]
+    return rest.split(".", 1)[0] if rest else None
+
+
+def _shape_text_color(module: nn.Module) -> str | None:
+    subpkg = _builtin_subpackage_key(module)
+    if subpkg is None:
+        return None
+
+    style = _BUILTIN_SUBPACKAGE_STYLE.get(subpkg)
+    if style is None:
+        return None
+
+    _, stroke = style
+    return stroke
+
+
+def _parse_rgba(value: str) -> tuple[str, float] | None:
+    v = value.strip().lower()
+    if not v.startswith("rgba(") or not v.endswith(")"):
+        return None
+
+    inner = v[5:-1]
+    parts = [p.strip() for p in inner.split(",")]
+    if len(parts) != 4:
+        return None
+
+    try:
+        r, g, b = (int(float(x)) for x in parts[:3])
+        a = float(parts[3])
+    except Exception:
+        return None
+
+    r = max(0, min(255, r))
+    g = max(0, min(255, g))
+    b = max(0, min(255, b))
+    a = max(0.0, min(1.0, a))
+
+    return (f"#{r:02x}{g:02x}{b:02x}", a)
+
+
+def _container_attr_label(node: _ModuleNode) -> str | None:
+    if not isinstance(node.module, (nn.Sequential, nn.ModuleList, nn.ModuleDict)):
+        return None
+    if not node.name:
+        return None
+
+    leaf = node.name.rsplit(".", 1)[-1]
+    if leaf.isdigit():
+        return None
+
+    return leaf
+
+
+def _escape_label(text: str) -> str:
+    return text.replace('"', "&quot;")
+
+
+def _shape_str(shape: object) -> str:
+    try:
+        if isinstance(shape, tuple):
+            return "(" + ",".join(str(x) for x in shape) + ")"
+    except Exception:
+        pass
+    return str(shape)
+
+
+def _flatten_shapes(obj: object) -> list[tuple[int, ...]]:
+    shapes: list[tuple[int, ...]] = []
+    for t in _flatten_tensors(obj):
+        try:
+            shapes.append(tuple(int(x) for x in t.shape))
+        except Exception:
+            continue
+    return shapes
+
+
+def _shapes_brief(shapes: list[tuple[int, ...]]) -> str:
+    if not shapes:
+        return "?"
+    if len(shapes) == 1:
+        return _shape_str(shapes[0])
+    return f"{_shape_str(shapes[0])}x{len(shapes)}"
+
+
+def _node_signature(node: _ModuleNode) -> tuple:
+    return (type(node.module), tuple(_node_signature(c) for c in node.children))
+
+
+def _collapse_repeated_children(
+    children: list[_ModuleNode], *, repeat_min: int
+) -> list[_ModuleNode]:
+    if repeat_min <= 1:
+        return children
+
+    out: list[_ModuleNode] = []
+    i = 0
+    while i < len(children):
+        base = children[i]
+        base_sig = _node_signature(base)
+        j = i + 1
+        while j < len(children) and _node_signature(children[j]) == base_sig:
+            j += 1
+
+        run = children[i:j]
+        if len(run) >= repeat_min:
+            out.append(
+                _ModuleNode(
+                    module=base.module,
+                    name=base.name,
+                    depth=base.depth,
+                    children=base.children,
+                    group=[n.module for n in run],
+                )
+            )
+        else:
+            out.extend(run)
+
+        i = j
+    return out
+
+
+def build_mermaid_chart(
+    module: nn.Module,
+    input_shape: _ShapeLike | list[_ShapeLike] | None = None,
+    inputs: Iterable[Tensor] | Tensor | None = None,
+    depth: int = 2,
+    direction: str = "LR",
+    include_io: bool = True,
+    show_params: bool = False,
+    return_lines: bool = False,
+    copy_to_clipboard: bool = False,
+    compact: bool = False,
+    use_class_defs: bool = False,
+    end_semicolons: bool = True,
+    edge_mode: Literal["dataflow", "execution"] = "execution",
+    collapse_repeats: bool = True,
+    repeat_min: int = 2,
+    color_by_subpackage: bool = True,
+    container_name_from_attr: bool = True,
+    edge_stroke_width: float = 2.0,
+    emphasize_model_title: bool = True,
+    model_title_font_px: int = 20,
+    show_shapes: bool = False,
+    hide_subpackages: Iterable[str] = (),
+    hide_module_names: Iterable[str] = (),
+    dash_multi_input_edges: bool = True,
+    subgraph_fill: str = "#000000",
+    subgraph_fill_opacity: float = 0.05,
+    subgraph_stroke: str = "#000000",
+    subgraph_stroke_opacity: float = 0.75,
+    force_text_color: str | None = None,
+    edge_curve: str = "natural",
+    node_spacing: int = 50,
+    rank_spacing: int = 50,
+    **forward_kwargs,
+) -> str | list[str]:
+    if inputs is None and input_shape is None:
+        raise ValueError("Either inputs or input_shape must be provided.")
+    if depth < 0:
+        raise ValueError("depth must be >= 0")
+
+    tree = _build_tree(
+        module,
+        depth=0,
+        max_depth=depth,
+        collapse_repeats=collapse_repeats,
+        repeat_min=repeat_min,
+        hide_subpackages=set(hide_subpackages),
+        hide_module_names=set(hide_module_names),
+    )
+
+    nodes: list[_ModuleNode] = []
+
+    def _collect(n: _ModuleNode) -> None:
+        nodes.append(n)
+        for c in n.children:
+            _collect(c)
+
+    _collect(tree)
+
+    module_to_node: dict[nn.Module, _ModuleNode] = {n.module: n for n in nodes}
+
+    module_to_id: dict[nn.Module, str] = {}
+    for idx, n in enumerate(nodes):
+        node_id = f"m{idx}"
+        for mod in n.iter_modules():
+            module_to_id[mod] = node_id
+
+    def _build_parent_map(root: nn.Module) -> dict[nn.Module, nn.Module]:
+        parent: dict[nn.Module, nn.Module] = {}
+
+        def _walk(mod: nn.Module) -> None:
+            for child in mod._modules.values():
+                parent[child] = mod
+                _walk(child)
+
+        _walk(root)
+        return parent
+
+    parent_map = _build_parent_map(module)
+    has_non_root_included = any(mod is not module for mod in module_to_id)
+
+    def _map_to_included(mod: nn.Module) -> nn.Module | None:
+        cur = mod
+        while cur not in module_to_id and cur in parent_map:
+            cur = parent_map[cur]
+        return cur if cur in module_to_id else None
+
+    hooks = []
+    edges: set[tuple[str, str]] = set()
+    tensor_producer: dict[int, nn.Module] = {}
+    module_in_shapes: dict[nn.Module, list[tuple[int, ...]]] = {}
+    module_out_shapes: dict[nn.Module, list[tuple[int, ...]]] = {}
+    input_node_id = "input"
+    output_node_id = "output"
+    root_module = module
+    exec_order: list[nn.Module] = []
+
+    def _hook(
+        mod: nn.Module, input_arg: tuple, output: Tensor | tuple[Tensor, ...]
+    ) -> None:
+        mapped_mod = _map_to_included(mod)
+        if mapped_mod is None:
+            return
+
+        if show_shapes:
+            module_in_shapes[mapped_mod] = _flatten_shapes(input_arg)
+            module_out_shapes[mapped_mod] = _flatten_shapes(output)
+
+        if edge_mode == "dataflow":
+            input_tensors = _flatten_tensors(input_arg)
+            for t in input_tensors:
+                producer = tensor_producer.get(id(t))
+                if producer is None:
+                    if include_io and (
+                        mapped_mod is not root_module or not has_non_root_included
+                    ):
+                        edges.add((input_node_id, module_to_id[mapped_mod]))
+
+                else:
+                    if producer is not mapped_mod:
+                        edges.add((module_to_id[producer], module_to_id[mapped_mod]))
+
+        output_tensors = _flatten_tensors(output)
+        for t in output_tensors:
+            key = id(t)
+            if mapped_mod is root_module and key in tensor_producer:
+                continue
+            tensor_producer[key] = mapped_mod
+
+        exec_order.append(mapped_mod)
+
+    for mod in module.modules():
+        hooks.append(mod.register_forward_hook(_hook))
+
+    try:
+        if inputs is None:
+            if isinstance(input_shape, list):
+                input_tensors = [
+                    lucid.random.randn(shape, device=module.device)
+                    for shape in input_shape
+                ]
+            else:
+                input_tensors = [lucid.random.randn(input_shape, device=module.device)]
+        else:
+            if isinstance(inputs, Tensor):
+                input_tensors = [inputs]
+            else:
+                input_tensors = list(inputs)
+
+        outputs = module(*input_tensors, **forward_kwargs)
+    finally:
+        for remove in hooks:
+            remove()
+
+    model_input_shapes = _flatten_shapes(input_tensors)
+    model_output_shapes = _flatten_shapes(outputs)
+
+    if edge_mode == "execution":
+        seq = []
+        for m in exec_order:
+            if not seq or seq[-1] is not m:
+                seq.append(m)
+        seq_no_root = [m for m in seq if m is not root_module]
+        if not seq_no_root:
+            seq_no_root = [root_module]
+
+        def _is_included_container(mod: nn.Module) -> bool:
+            node = module_to_node.get(mod)
+            return bool(node and node.children)
+
+        seq_effective = [m for m in seq_no_root if not _is_included_container(m)]
+        if not seq_effective:
+            seq_effective = seq_no_root
+
+        for prev, cur in zip(seq_effective, seq_effective[1:]):
+            edges.add((module_to_id[prev], module_to_id[cur]))
+
+        if include_io and seq_effective:
+            edges.add((input_node_id, module_to_id[seq_effective[0]]))
+            edges.add((module_to_id[seq_effective[-1]], output_node_id))
+
+    else:
+        if include_io:
+            output_tensors = _flatten_tensors(outputs)
+            for t in output_tensors:
+                producer = tensor_producer.get(id(t))
+                if producer is not None:
+                    edges.add((module_to_id[producer], output_node_id))
+
+    node_ids = set(module_to_id.values())
+    nodes_with_edges: set[str] = set()
+
+    for src, dst in edges:
+        if src in node_ids:
+            nodes_with_edges.add(src)
+        if dst in node_ids:
+            nodes_with_edges.add(dst)
+
+    container_node_ids = {module_to_id[n.module] for n in nodes if n.children}
+    container_with_edges = container_node_ids & nodes_with_edges
+    extra_edges: list[tuple[str, str]] = []
+
+    def _endpoint_in(node_id: str) -> str:
+        return f"{node_id}_in" if node_id in container_with_edges else node_id
+
+    def _endpoint_out(node_id: str) -> str:
+        return f"{node_id}_out" if node_id in container_with_edges else node_id
+
+    def _first_leaf_id(n: _ModuleNode) -> str:
+        cur = n
+        while cur.children:
+            cur = cur.children[0]
+        return module_to_id[cur.module]
+
+    def _last_leaf_id(n: _ModuleNode) -> str:
+        cur = n
+        while cur.children:
+            cur = cur.children[-1]
+        return module_to_id[cur.module]
+
+    lines: list[str] = []
+    init_cfg: dict[str, object] = {
+        "flowchart": {
+            "curve": "step" if edge_curve == "round" else edge_curve,
+            "nodeSpacing": node_spacing,
+            "rankSpacing": rank_spacing,
+        }
+    }
+    css_parts: list[str] = []
+    if edge_curve == "round":
+        css_parts.append(
+            ".edgePath path { stroke-linecap: round; stroke-linejoin: round; }"
+        )
+    if force_text_color:
+        css_parts.append(
+            f".nodeLabel, .edgeLabel, .cluster text, .node text "
+            f"{{ fill: {force_text_color} !important; }} "
+            f".node foreignObject *, .cluster foreignObject * "
+            f"{{ color: {force_text_color} !important; }}"
+        )
+    if css_parts:
+        init_cfg["themeCSS"] = " ".join(css_parts)
+
+    lines.append(f"%%{{init: {json.dumps(init_cfg, separators=(',', ':'))} }}%%")
+    lines.append(f"flowchart {direction}")
+
+    if edge_stroke_width and edge_stroke_width != 1.0:
+        lines.append(f"  linkStyle default stroke-width:{edge_stroke_width}px")
+
+    if use_class_defs:
+        lines.append("  classDef module fill:#f9f9f9,stroke:#333,stroke-width:1px;")
+        lines.append("  classDef modelio fill:#fff3cd,stroke:#a67c00,stroke-width:1px;")
+        lines.append(
+            "  classDef internalio fill:#e2e8f0,stroke:#64748b,stroke-width:1px;"
+        )
+        lines.append(
+            "  classDef anchor fill:transparent,stroke:transparent,color:transparent;"
+        )
+        lines.append("  classDef repeat fill:#e8f1ff,stroke:#2b6cb0,stroke-width:1px;")
+
+    vertical_levels: set[int] = set()
+    if depth >= 3:
+        vertical_levels = {depth - 2, depth - 1}
+
+    def _render(n: _ModuleNode, indent: str = "  ") -> None:
+        node_id = module_to_id[n.module]
+        base_label = _module_label(n.module, show_params)
+
+        if container_name_from_attr and n.children:
+            attr_label = _container_attr_label(n)
+            if attr_label is not None:
+                base_label = attr_label
+
+        base_label = _escape_label(base_label)
+        label_text = base_label if n.count == 1 else f"{base_label} x {n.count}"
+
+        if show_shapes and not n.children:
+            in_shapes = module_in_shapes.get(n.module, [])
+            out_shapes = module_out_shapes.get(n.module, [])
+
+            if in_shapes != out_shapes and (in_shapes or out_shapes):
+                ins = _shapes_brief(in_shapes)
+                outs = _shapes_brief(out_shapes)
+                color_css = ""
+                if not force_text_color:
+                    color = _shape_text_color(n.module)
+                    color_css = f"color:{color};" if color else ""
+                label_text = (
+                    f"{label_text}<br/>"
+                    f"<span style='font-size:11px;{color_css}font-weight:400'>"
+                    f"{ins} \u2192 {outs}"
+                    f"</span>"
+                )
+
+        label = label_text
+        if (
+            emphasize_model_title
+            and n.module is root_module
+            and model_title_font_px
+            and model_title_font_px > 0
+        ):
+            label = (
+                f"<span style='font-size:{model_title_font_px}px;font-weight:700'>"
+                f"{label}"
+                f"</span>"
+            )
+
+        if n.children:
+            lines.append(f'{indent}subgraph sg_{node_id}["{label}"]')
+            if n.depth in vertical_levels:
+                lines.append(f"{indent}  direction TB")
+            if subgraph_fill or subgraph_stroke:
+                parts: list[str] = []
+
+                fill = subgraph_fill
+                fill_opacity = subgraph_fill_opacity
+                parsed = _parse_rgba(fill)
+
+                if parsed is not None:
+                    fill, fill_opacity = parsed
+                if fill:
+                    parts.append(f"fill:{fill}")
+                    parts.append(f"fill-opacity:{fill_opacity}")
+
+                stroke = subgraph_stroke
+                stroke_opacity = subgraph_stroke_opacity
+                if stroke:
+                    parsed = _parse_rgba(stroke)
+                    if parsed is not None:
+                        stroke, stroke_opacity = parsed
+
+                    parts.append(f"stroke:{stroke}")
+                    parts.append(f"stroke-opacity:{stroke_opacity}")
+                    parts.append("stroke-width:1px")
+
+                lines.append(f'{indent}style sg_{node_id} {",".join(parts)}')
+
+            if node_id in nodes_with_edges:
+                if node_id in container_with_edges:
+                    in_id = f"{node_id}_in"
+                    out_id = f"{node_id}_out"
+
+                    if use_class_defs:
+                        lines.append(f'{indent}  {in_id}(["Input"]):::internalio')
+                        lines.append(f'{indent}  {out_id}(["Output"]):::internalio')
+                    else:
+                        lines.append(f'{indent}  {in_id}(["Input"])')
+                        lines.append(f'{indent}  {out_id}(["Output"])')
+                        lines.append(
+                            f"  style {in_id} fill:#e2e8f0,stroke:#64748b,stroke-width:1px;"
+                        )
+                        lines.append(
+                            f"  style {out_id} fill:#e2e8f0,stroke:#64748b,stroke-width:1px;"
+                        )
+
+                    extra_edges.append((in_id, _endpoint_in(_first_leaf_id(n))))
+                    extra_edges.append((_endpoint_out(_last_leaf_id(n)), out_id))
+
+                else:
+                    if use_class_defs:
+                        lines.append(f'{indent}  {node_id}[""]:::anchor')
+                    else:
+                        lines.append(f'{indent}  {node_id}["\u200b"]')
+                        lines.append(
+                            f"  style {node_id} fill:transparent,stroke:transparent,color:transparent;"
+                        )
+
+            for c in n.children:
+                _render(c, indent + "  ")
+            lines.append(f"{indent}end")
+
+        else:
+            if use_class_defs:
+                class_name = "module" if n.count == 1 else "repeat"
+                lines.append(f'{indent}{node_id}["{label}"]:::{class_name}')
+            else:
+                if n.count > 1:
+                    lines.append(f'{indent}{node_id}(["{label}"])')
+                else:
+                    lines.append(f'{indent}{node_id}["{label}"]')
+
+    _render(tree)
+
+    if include_io:
+        input_label = "Input"
+        output_label = "Output"
+        if show_shapes:
+            in_s = _shapes_brief(model_input_shapes)
+            out_s = _shapes_brief(model_output_shapes)
+            io_color = force_text_color or "#a67c00"
+            input_label = (
+                f"{input_label}<br/>"
+                f"<span style='font-size:11px;color:{io_color};font-weight:400'>{in_s}</span>"
+            )
+            output_label = (
+                f"{output_label}<br/>"
+                f"<span style='font-size:11px;color:{io_color};font-weight:400'>{out_s}</span>"
+            )
+        if use_class_defs:
+            lines.append(f'  {input_node_id}["{input_label}"]:::modelio')
+            lines.append(f'  {output_node_id}["{output_label}"]:::modelio')
+        else:
+            lines.append(f'  {input_node_id}["{input_label}"]')
+            lines.append(f'  {output_node_id}["{output_label}"]')
+            lines.append(
+                f"  style {input_node_id} fill:#fff3cd,stroke:#a67c00,stroke-width:1px;"
+            )
+            lines.append(
+                f"  style {output_node_id} fill:#fff3cd,stroke:#a67c00,stroke-width:1px;"
+            )
+
+    if color_by_subpackage:
+        for n in nodes:
+            if n.children:
+                continue
+
+            subpkg = _builtin_subpackage_key(n.module)
+            if subpkg is None:
+                continue
+            style = _BUILTIN_SUBPACKAGE_STYLE.get(subpkg)
+            if style is None:
+                continue
+
+            fill, stroke = style
+            node_id = module_to_id[n.module]
+            if node_id in {input_node_id, output_node_id}:
+                continue
+
+            if node_id.endswith("_in") or node_id.endswith("_out"):
+                continue
+            lines.append(
+                f"  style {node_id} fill:{fill},stroke:{stroke},stroke-width:1px;"
+            )
+
+    render_edges: set[tuple[str, str]] = set()
+    for src, dst in edges:
+        src_id = _endpoint_out(src)
+        dst_id = _endpoint_in(dst)
+        if src_id != dst_id:
+            render_edges.add((src_id, dst_id))
+
+    for src, dst in extra_edges:
+        if src != dst:
+            render_edges.add((src, dst))
+
+    indegree: dict[str, int] = {}
+    for _, dst in render_edges:
+        indegree[dst] = indegree.get(dst, 0) + 1
+
+    for src, dst in sorted(render_edges):
+        arrow = "-.->" if dash_multi_input_edges and indegree.get(dst, 0) > 1 else "-->"
+        lines.append(f"  {src} {arrow} {dst}")
+
+    def _finalize_lines(src_lines: list[str]) -> list[str]:
+        if not end_semicolons:
+            return src_lines
+
+        out: list[str] = []
+        for line in src_lines:
+            stripped = line.rstrip()
+            head = stripped.lstrip()
+            if (
+                not head
+                or head.startswith("flowchart ")
+                or head.startswith("linkStyle ")
+                or head.startswith("subgraph ")
+                or head == "end"
+                or head.startswith("classDef ")
+                or head.startswith("class ")
+                or head.startswith("style ")
+                or head.startswith("%%")
+            ):
+                out.append(line)
+                continue
+
+            if stripped.endswith(";"):
+                out.append(line)
+            else:
+                out.append(f"{line};")
+
+        return out
+
+    final_lines = _finalize_lines(lines)
+
+    if compact:
+        text = " ".join(final_lines)
+    else:
+        text = "\n".join(final_lines)
+    if copy_to_clipboard:
+        _copy_to_clipboard(text)
+
+    if return_lines:
+        return final_lines
+    return text
+
+
+def _copy_to_clipboard(text: str) -> None:
+    import os
+    import shutil
+    import subprocess
+    import sys
+
+    errors: list[str] = []
+
+    def _try(cmd: list[str]) -> bool:
+        try:
+            subprocess.run(cmd, input=text.encode("utf-8"), check=True)
+            return True
+        except Exception as e:
+            errors.append(f"{cmd!r}: {type(e).__name__}: {e}")
+            return False
+
+    if sys.platform == "darwin":
+        if shutil.which("pbcopy") and _try(["pbcopy"]):
+            return
+
+    elif sys.platform.startswith("win"):
+        if shutil.which("clip") and _try(["clip"]):
+            return
+        if shutil.which("powershell"):
+            try:
+                subprocess.run(
+                    ["powershell", "-NoProfile", "-Command", "Set-Clipboard"],
+                    input=text.encode("utf-8"),
+                    check=True,
+                )
+                return
+            except Exception as e:
+                errors.append(f"powershell Set-Clipboard: {type(e).__name__}: {e}")
+
+    else:
+        if os.environ.get("WAYLAND_DISPLAY") and shutil.which("wl-copy"):
+            if _try(["wl-copy"]):
+                return
+        if shutil.which("xclip"):
+            if _try(["xclip", "-selection", "clipboard"]):
+                return
+        if shutil.which("xsel"):
+            if _try(["xsel", "--clipboard", "--input"]):
+                return
+
+    try:
+        import tkinter
+
+        root = tkinter.Tk()
+        root.withdraw()
+        root.clipboard_clear()
+        root.clipboard_append(text)
+        root.update()
+        root.destroy()
+        return
+
+    except Exception as e:
+        errors.append(f"tkinter: {type(e).__name__}: {e}")
+
+    detail = "\n".join(f"- {msg}" for msg in errors) if errors else "- (no details)"
+    raise RuntimeError(
+        "Failed to copy to clipboard. Install a clipboard utility (macOS: pbcopy; "
+        "Wayland: wl-copy; X11: xclip/xsel; Windows: clip/powershell) or enable tkinter.\n"
+        f"{detail}"
+    )

{lucid_dl-2.11.2.dist-info → lucid_dl-2.11.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lucid-dl
-Version: 2.11.2
+Version: 2.11.3
 Summary: Lumerico's Comprehensive Interface for Deep Learning
 Home-page: https://github.com/ChanLumerico/lucid
 Author: ChanLumerico
@@ -48,26 +48,19 @@ Whether you're a student, educator, or an advanced researcher seeking to demysti
 
 ### 🔥 What's New
 
-- Added various inplace tensor operations (e.g. `a.add_(b)`, `a.mul_(b)`)
+- Added additional `nn.Module` hooks for richer introspection during training:
 
-- Added **Noise Conditional Score Network(NCSN)** to `lucid.models.NCSN`
+  ```python
+  def register_forward_pre_hook(self, hook: Callable, *, with_kwargs: bool = False)
 
-- Branched a Stand-Alone Autograd Engine as `lucid.autograd`
+  def register_forward_hook(self, hook: Callable, *, with_kwargs: bool = False)
 
-  - Provides a generalized API of computing gradients:
-    
-    ```python
-    import lucid.autograd as autograd
-    x = lucid.Tensor([1., 2.], requires_grad=True)
-    y = (x ** 2).sum()
-    autograd.grad(y, x)  # ∂y/∂x
-    ```
+  def register_backward_hook(self, hook: Callable)
 
-- Introduced **Backward Fusion** for CPU execution:
-  - Automatically fuses selected operation patterns during backpropagation to reduce graph overhead
-  - Supports identity/unary fusion (e.g. `log∘exp`, double negation, and view-like ops such as reshape/squeeze)
-  - Uses heuristic thresholds to avoid fusion overhead on small tensors
-  - Disabled by default on GPU paths to ensure stable performance
+  def register_full_backward_pre_hook(self, hook: Callable)
+
+  def register_full_backward_hook(self, hook: Callable)
+  ```
 
 ## 🔧 How to Install
 

{lucid_dl-2.11.2.dist-info → lucid_dl-2.11.3.dist-info}/RECORD

@@ -35,19 +35,19 @@ lucid/models/imgclf/__init__.py,sha256=kQH-nNu8_TPJ7Av151WSpcY4GJ06gGAd6Ozs3m3KM
 lucid/models/imgclf/alex.py,sha256=fZsPdCjWUseCrxBwKj-i5fPSDYLgBpfm0SJe07YKRuE,1472
 lucid/models/imgclf/coatnet.py,sha256=HKjpy-lBKgz743EijT7jEeMxYjrZHzgU5fOrgtZfxYg,13720
 lucid/models/imgclf/convnext.py,sha256=mCZwauNw9Czf_fRNWAmxEwqshc_p1TYBj-L_XFBankk,8046
-lucid/models/imgclf/crossvit.py,sha256=CJcNqUeVzchgOrrNqMeqNRiPZc3uBLPT1GwCxM-n60E,21299
+lucid/models/imgclf/crossvit.py,sha256=KKSC-Og5f5XmvBRcGC_hMUq6JZ-VdOIBWGxzilb_NIE,21305
 lucid/models/imgclf/cspnet.py,sha256=dTVwrYKECSqIfaGtYBO3TgcHYm1XyV6E2cXYvEZiuHQ,12618
 lucid/models/imgclf/cvt.py,sha256=oLGS-srIac1nHl8O6BFewcTM47DAJeUCHd2hRj_RXJ4,15567
 lucid/models/imgclf/dense.py,sha256=_fuw5Hpxm_9EKWz6IMVuGyp5gU6U2jfPfCDqByI_GRE,4431
 lucid/models/imgclf/efficient.py,sha256=X2WvLUOATT6bsA35LDPALq-FqNe1WCBJLl17r8xfx4w,13954
-lucid/models/imgclf/efficientformer.py,sha256=bX-hLl0YYjTeDc25yOtlQAwaHeVTFFr4TwJkW6l0w14,15184
+lucid/models/imgclf/efficientformer.py,sha256=K--25NspAixmSQQ6s6NPCY8envMXpSJ6Ajuj5A7nclY,15196
 lucid/models/imgclf/inception.py,sha256=vpTRvfedp0DWHChqBkLH_7jaS4-jqdpBTwC6EzhhM88,21239
 lucid/models/imgclf/inception_next.py,sha256=W68yrOAAtKnt9_bMt9zj4Fa5PrgfK930Qg6igSML7os,8800
 lucid/models/imgclf/inception_res.py,sha256=O8L9-EPXbAbOB6Ujp2Vhv_k_9xOWVDqiYScRxbFqJZg,8341
 lucid/models/imgclf/lenet.py,sha256=55g3M8-OkJ9Se0QP66dTGzPINaq6J3OCfQNu9NqX9NI,2135
-lucid/models/imgclf/maxvit.py,sha256=lZS9LBEIbM9D_x9Xf6EgJ_YAE-9DaZThDpOiK_fuhaY,17069
+lucid/models/imgclf/maxvit.py,sha256=SFq0IRBZBpHYPFr4LArDWz5qdGCkfrNqFCRjir_9jaY,17075
 lucid/models/imgclf/mobile.py,sha256=T52hZv2KfLGTp2e3mgxW-okmCFFIXP8EITcG5XQwhWc,34916
-lucid/models/imgclf/pvt.py,sha256=-rjswNvImFI3zjH-R1pPjNKWBLp6Mt17VXU2yKLo1jY,25985
+lucid/models/imgclf/pvt.py,sha256=It3e9TRcgAlystccVChE6auTCrkWV1ngOy0E4BhXhDg,25997
 lucid/models/imgclf/resnest.py,sha256=c2ajAS70qstlbGTlVC8CpDGhX1GH_IlkPb-I2ZuqGUg,6970
 lucid/models/imgclf/resnet.py,sha256=Xlz1oTJVUQNZqBRrXTXboLYm9CYU_kLJqR3Xos6FsFY,10111
 lucid/models/imgclf/resnext.py,sha256=iIoo42rVy58EefHokjfGVuXc3N6x4BEUjtYOS4eczM4,1745
@@ -61,14 +61,14 @@ lucid/models/imgclf/zfnet.py,sha256=brH5tHLVWTUfCqu-BwfFb0yZV9p5DmXN4O6cyP3U26U,
 lucid/models/imggen/__init__.py,sha256=J6MlEHqXxAYINbeQmyb85ev_IEOvQDTxTQjPgX6hdpY,59
 lucid/models/imggen/ddpm.py,sha256=Nyi5bp7WMzqZ8Xl2AXuLsMmdz9QSZifbbmMPMeY1YfQ,10752
 lucid/models/imggen/ncsn.py,sha256=TF_kqnXcPZx4C_eIBqwyeRf3jp7KtiHy3SxQDnbeCj4,13555
-lucid/models/imggen/vae.py,sha256=avR8W0rzIsUyJF6veJCIEHavRsPjJsSuTDqzO2wj6sU,4084
+lucid/models/imggen/vae.py,sha256=6KNY_mvalm7Kdu-StfaOtm7B1k_mW1XkFBmjwhaK8QU,4084
 lucid/models/objdet/__init__.py,sha256=y8_3gjSKlD8Pu0HYburcJ1FAOb4SG5eza_lg9SdFjy8,140
 lucid/models/objdet/detr.py,sha256=i-KbNoPA9nUuUVBAKRHER-NB6z_sFF5r3Y3oplRaJkI,30336
-lucid/models/objdet/efficientdet.py,sha256=o5sSB4giRdTdlDhxp8OkIQXxqLj97eMeLdmSqYlDlWA,22602
+lucid/models/objdet/efficientdet.py,sha256=lU_dUVR9AebxPBcbDEU4uY9nWOPaDrcPThmuyx1yv2Y,23125
 lucid/models/objdet/fast_rcnn.py,sha256=d3IdI1UdN3CVhC5oPEp1cqo7Mf-d4oqaq3epm8sZgNk,5613
 lucid/models/objdet/faster_rcnn.py,sha256=wFIcQuKTpsO3H_zcrRLh5p4MdpPksV0cyC53QBekqLI,21671
-lucid/models/objdet/rcnn.py,sha256=GC0Wh1zUyZ4Bh_iw8sRmpGuoDhqzgrRU_dIYe8e9xTQ,6981
-lucid/models/objdet/util.py,sha256=_92_sPhHZBW6Mc0GFgiBk1eOghMCzWBT8UBP-B9PXek,17016
+lucid/models/objdet/rcnn.py,sha256=IeyhE75iJtYxj99szeUvP-sYOMYGsKZcxcaBxVqqUK0,6987
+lucid/models/objdet/util.py,sha256=KYWhx_aMiihabA4od0AXxen-EQsZMud50_b2OiJ4eqo,17147
 lucid/models/objdet/yolo/__init__.py,sha256=dBpDRsIdU6G0Q3ldBzVXdJ1yrQz0kTt2v2z-KUtVT3s,92
 lucid/models/objdet/yolo/yolo_v1.py,sha256=WEYexKTigLweN_wABq8VBBZjfzN8p2Bmawuc1Ayexbk,7160
 lucid/models/objdet/yolo/yolo_v2.py,sha256=AGl3Hlw7SCzqSVwK52m6__0MV7KmMbgvAVR6PtluOQo,12227
@@ -78,7 +78,7 @@ lucid/models/seq2seq/__init__.py,sha256=wjsrhj4H_AcqwwbebAN8b68QBA8L6p1_12dkG299
 lucid/models/seq2seq/transformer.py,sha256=y5rerCs1s6jXTsVvbgscWScKpQKuSu1fezsBe7PNTRA,3513
 lucid/nn/__init__.py,sha256=_hk6KltQIJuWXowXstMSu3TjiaTP8zMLNvGpjnA9Mpw,182
 lucid/nn/fused.py,sha256=75fcXuo6fHSO-JtjuKhowhHSDr4qc5871WR63sUzH0g,5492
-lucid/nn/module.py,sha256=XvFWJ8NqXeZpr3RmKBQBz5eqT535Oi_7DaPN1Zi9gJc,21971
+lucid/nn/module.py,sha256=B2esFTdKJFjqsNUsFhVx_7IE-5nyJwW4b2I8QG1iLUk,25791
 lucid/nn/parameter.py,sha256=NQS65YKn2B59wZbZIoT1mpDsU_F08y3yLi7hmV1B6yo,1232
 lucid/nn/util.py,sha256=Yw1iBSPrGV_r_F51qpqLYdafNE_hyaA0DPWYP-rjaig,1699
 lucid/nn/_kernel/__init__.py,sha256=n1bnYdeb_bNDBKASWGywTRa0Ne9hMAkal3AuVZJgovI,5
@@ -130,12 +130,13 @@ lucid/random/_func.py,sha256=1Lu4m-ciEK037chNDGqv_j00RgGGzQ7UfslSfYActUk,2232
 lucid/transforms/__init__.py,sha256=DGznMbqhXdU9FLDMKnJawScO4HCqu40Sf_j4vJGJrjc,90
 lucid/transforms/_base.py,sha256=v3elm7l0VoWvrT_qgoJiRzLH42tHoUcPIKNaPuxI_2E,1448
 lucid/transforms/image.py,sha256=S9gZzMck4EQSmDQZ3ATi2fsUh4-hqFqeDjhMMJe8TdU,3762
-lucid/visual/__init__.py,sha256=6TuFDfmXTwpLyHl7_KqBfdzW6zqHjGzIFvymjFPlvjI,21
-lucid/visual/graph.py,sha256=YjpIDM_lloZARw3sCBiXPl_hT5A2gTk2fEHvwvJWXTk,4599
+lucid/visual/__init__.py,sha256=NfHhHYNVv9mQQ4MST3-OAIkAcFyYrihJC4qUf88DySI,44
+lucid/visual/graph.py,sha256=ZSlrJI3dQwYjz8XbgAfNd8-8YuH9Ji7Mz1J6UsnHTaI,4711
+lucid/visual/mermaid.py,sha256=87hFe4l9EYP6Cg2l2hP2INQiBHKkgVClH5nBWFY9ddY,26499
 lucid/weights/__init__.py,sha256=z1AikA3rOEeckWGkYWlcZkxNlJo9Xwa39PL6ly3hWnc,8801
 lucid/weights/__init__.pyi,sha256=lFonYC3cUx2Idolf3AEPnjFcyqcn3UDU84oJlZafqLY,3013
-lucid_dl-2.11.2.dist-info/licenses/LICENSE,sha256=vxRFYnVD1IeYtsvw-KmoElfqrjxKHv1h9YTvsG54loQ,1065
-lucid_dl-2.11.2.dist-info/METADATA,sha256=udbwTB1UUVhJNWAWTGG_aqKNovOu-Qb_iLTi_HVb13I,12312
-lucid_dl-2.11.2.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
-lucid_dl-2.11.2.dist-info/top_level.txt,sha256=uzP_qBx9iNWIHKJRlElYcBLYVqMpdm9Q1Ma63QPYbFc,6
-lucid_dl-2.11.2.dist-info/RECORD,,
+lucid_dl-2.11.3.dist-info/licenses/LICENSE,sha256=vxRFYnVD1IeYtsvw-KmoElfqrjxKHv1h9YTvsG54loQ,1065
+lucid_dl-2.11.3.dist-info/METADATA,sha256=hffKVg1_fBZA5K3NcRn9KUkIv7B7ilHgr_9OJscZlR0,11898
+lucid_dl-2.11.3.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+lucid_dl-2.11.3.dist-info/top_level.txt,sha256=uzP_qBx9iNWIHKJRlElYcBLYVqMpdm9Q1Ma63QPYbFc,6
+lucid_dl-2.11.3.dist-info/RECORD,,

{lucid_dl-2.11.2.dist-info → lucid_dl-2.11.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.10.1)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any