ulpwise 0.3.3__tar.gz → 0.3.4__tar.gz

{ulpwise-0.3.3 → ulpwise-0.3.4}/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## 0.3.4 (2026-10-09)
+
+- Regression corpus case for pytorch/rl #4504, merged upstream: `MultiCategorical.to_one_hot` iterated over `self.nvec`,
+  a 2-D tensor for a spec with a batch shape, so `one_hot` got a tensor as `num_classes` and raised `TypeError`, and the
+  0-D sample of a shape `[1]` spec raised `IndexError` on `val[..., i]`. The case one-hot encodes a sample of
+  `MultiCategorical([3, 2], shape=(4, 2))` and the scalar sample of `MultiCategorical([5])`.
+- `ulpwise scan`: new `dropout-never-applied` rule (medium), the first that reads a whole file rather than one
+  function: a `Dropout`, `DropPath` or a `ModuleDict` or `ModuleList` under a dropout name is assigned to `self`
+  and then never called, never passed on, never returned or iterated and its rate never read, anywhere in the file.
+  The option is accepted and does nothing, so the model trains without the regularisation it reports. peft #3830 is
+  the example: `OFTLayer` built `module_dropout` into `self.oft_dropout`, filled it in `update_layer` and never
+  called it. Reading the rate counts as use (`scaled_dot_product_attention(dropout_p=self.dropout.p)`), as does
+  passing the module to another one; filling it does not, and subclasses of `Sequential`, which run every
+  attribute, are not read. On kornia, ultralytics, torchvision, diffusers, torchrl, vllm and detectron2 main the
+  rule reports nothing; on peft main it reports the #3830 line, on timm main one `attn_drop` in `coat.py` that a
+  comment already calls unused, and on transformers main nine lines, four of them modular files whose `forward`
+  lives in another file.
+
 ## 0.3.3 (2026-10-08)
 
 - Two regression corpus cases for peft, both open upstream with a fix PR: peft #3769, `add_weighted_adapter` with

{ulpwise-0.3.3 → ulpwise-0.3.4}/Cargo.lock

@@ -120,7 +120,7 @@ checksum = "adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca"
 
 [[package]]
 name = "ulpwise"
-version = "0.3.3"
+version = "0.3.4"
 dependencies = [
  "pyo3",
 ]

{ulpwise-0.3.3 → ulpwise-0.3.4}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ulpwise"
-version = "0.3.3"
+version = "0.3.4"
 edition = "2021"
 rust-version = "1.86"
 license = "MIT OR Apache-2.0"

{ulpwise-0.3.3 → ulpwise-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ulpwise
-Version: 0.3.3
+Version: 0.3.4
 Classifier: Development Status :: 3 - Alpha
 Classifier: Framework :: Pytest
 Classifier: Intended Audience :: Developers
@@ -185,6 +185,7 @@ PYTHONPATH=/tmp/kornia-0.8.3 ulpwise corpus --repo kornia     # 31 present, 0 fi
 | pytorch/rl #4443 `arange(0, 1, 1/n)` gives `n + 1` positions for 140 values of `n` below 2000 | rounding | 2026-09-20 |
 | pytorch/rl #4444 `min_value or -inf` drops `min_value=0` | falsy zero | 2026-09-20 |
 | pytorch/rl #4445 scheduler `state_dict()` contained a module object | crash | 2026-09-20 |
+| pytorch/rl #4504 `MultiCategorical.to_one_hot` crashed for a batched spec and a 0-D sample | crash | 2026-10-07 |
 | timm #2786 Mars kept a reference to `p.grad` as the previous gradient | aliasing | 2026-09-17 |
 | timm #2790 AdafactorBigVision clipped updates in the wrong direction | direction | 2026-09-18 |
 | timm #2791 AdaMuon conv LR scale computed from the wrong dims | scale | 2026-09-18 |
@@ -249,9 +250,9 @@ ulpwise scan path/to/repo --rules one-minus-cos,small-angle-division --top 40
 ```
 
 The scan is static and needs nothing installed: it parses each file with `ast`, walks every
-function and matches fifteen patterns, each with a severity, the reason it loses digits,
-overflows or loses its gradient, the usual replacement and, where one exists, the upstream bug it
-comes from.
+function and matches sixteen patterns, each with a severity, the reason it loses digits,
+overflows or loses its gradient, or in one case does nothing at all, the usual replacement and,
+where one exists, the upstream bug it comes from.
 
 | rule | severity | pattern |
 |---|---|---|
@@ -269,6 +270,7 @@ comes from.
 | `eps-floor` | medium | `x * (1 - eps) + eps`: every value moves, 0 becomes `eps`, so a one-hot's entries sum to `1 + (C - 1) eps` and a perfect prediction scores a loss that grows with the image (kornia #5538, found by the kornia conventions audit) |
 | `where-nan-gradient` | medium | `where(d > eps, f(d), other)` with `f` a division by `d` or a `sqrt`, `log`, `acos` or `asin` of it: `where` evaluates both branches and hands the discarded one a zero gradient, and the backward of `f` at the singularity turns that zero into `0 / 0 = nan`, so the guard protects the value and not the gradient; quiet for `numpy.where`, for a comparison against a number above 1, for a floor named `eps`, `tol` or `floor` on the other side, and once `d` is re-bound to a `where`, `clamp` or `maximum` of itself (kornia #5579, found by the kornia conventions audit) |
 | `clamp-at-singularity` | medium | `clamp(x, min=0).sqrt()`, `sqrt(clamp(x, min=0))`, `clamp(c, -1, 1).acos()`: the bound is the point where the next function has an infinite derivative, and clamp's derivative at its own bound is not the same across torch versions, 1 on 2.5.1 and 2.9.1 and 0 on 2.14, so the gradient there is `inf` or `nan` on the older half of a supported range; a bound strictly inside the domain, `min=1e-8`, is a floor and is not reported, and `numpy` is quiet (kornia #4229, found by the kornia conventions audit; kornia #5500) |
+| `dropout-never-applied` | medium | a `Dropout`, `DropPath` or a `ModuleDict` of them assigned to `self` and then never called, never passed on and its rate never read, anywhere in the file: the option is accepted and does nothing, so the model trains without the regularisation it reports (peft #3830) |
 
 On kornia `main` at `e05b0ee` the scan takes 4 s for 506 files and reports 35 findings. The
 `one-minus-cos` and `small-angle-division` findings are the four lines of `So3.right_jacobian` and
@@ -284,6 +286,19 @@ report seven lines: three `clamp` bounds in `_solve_cubic_real`, and four `where
 boxes and polygons. On ultralytics `main` at `8df3534` they report three lines, all in metrics or
 inference code that is never differentiated, and nothing in torchvision.
 
+`dropout-never-applied` reads the whole file rather than one function, since the module is built
+in `__init__` and used, if at all, in `forward` or in a sibling class. Calling it, calling it
+through a subscript, passing it to another module, returning it, iterating over it and reading
+its rate (`scaled_dot_product_attention(dropout_p=self.dropout.p)`) all count as use; filling it
+(`self.oft_dropout.update(...)`) does not, and a subclass of `Sequential` runs every attribute and
+is not read. On kornia `main` at `6d579a72`, ultralytics `6d51b7e`, torchvision `9a8d545`,
+diffusers `d961a38`, torchrl `648f50c`, vllm `73c742b` and detectron2 `1e3e13b` it reports
+nothing. On peft `main` at `f6d8480` it reports `OFTLayer.oft_dropout`, which is #3830; on timm
+`83e6eb5` it reports `FactorAttnConvRelPosEnc.attn_drop` in `coat.py`, which a comment on that
+line already calls unused; on transformers `9167f73` it reports nine lines, four of them in
+modular files whose `forward` is inherited from another file, which the rule cannot see, and
+five attention, embedding and head dropouts built in `__init__` and used nowhere in their file.
+
 `--run` adds the dynamic half. The module level functions with the most elementary math are
 imported and called with the same 91 point grid (both signs of `1e-8` to `1e3`, and zero) for every
 required argument, in float32 and in float64, torch first and numpy second, and the float32 result

{ulpwise-0.3.3 → ulpwise-0.3.4}/README.md

@@ -156,6 +156,7 @@ PYTHONPATH=/tmp/kornia-0.8.3 ulpwise corpus --repo kornia     # 31 present, 0 fi
 | pytorch/rl #4443 `arange(0, 1, 1/n)` gives `n + 1` positions for 140 values of `n` below 2000 | rounding | 2026-09-20 |
 | pytorch/rl #4444 `min_value or -inf` drops `min_value=0` | falsy zero | 2026-09-20 |
 | pytorch/rl #4445 scheduler `state_dict()` contained a module object | crash | 2026-09-20 |
+| pytorch/rl #4504 `MultiCategorical.to_one_hot` crashed for a batched spec and a 0-D sample | crash | 2026-10-07 |
 | timm #2786 Mars kept a reference to `p.grad` as the previous gradient | aliasing | 2026-09-17 |
 | timm #2790 AdafactorBigVision clipped updates in the wrong direction | direction | 2026-09-18 |
 | timm #2791 AdaMuon conv LR scale computed from the wrong dims | scale | 2026-09-18 |
@@ -220,9 +221,9 @@ ulpwise scan path/to/repo --rules one-minus-cos,small-angle-division --top 40
 ```
 
 The scan is static and needs nothing installed: it parses each file with `ast`, walks every
-function and matches fifteen patterns, each with a severity, the reason it loses digits,
-overflows or loses its gradient, the usual replacement and, where one exists, the upstream bug it
-comes from.
+function and matches sixteen patterns, each with a severity, the reason it loses digits,
+overflows or loses its gradient, or in one case does nothing at all, the usual replacement and,
+where one exists, the upstream bug it comes from.
 
 | rule | severity | pattern |
 |---|---|---|
@@ -240,6 +241,7 @@ comes from.
 | `eps-floor` | medium | `x * (1 - eps) + eps`: every value moves, 0 becomes `eps`, so a one-hot's entries sum to `1 + (C - 1) eps` and a perfect prediction scores a loss that grows with the image (kornia #5538, found by the kornia conventions audit) |
 | `where-nan-gradient` | medium | `where(d > eps, f(d), other)` with `f` a division by `d` or a `sqrt`, `log`, `acos` or `asin` of it: `where` evaluates both branches and hands the discarded one a zero gradient, and the backward of `f` at the singularity turns that zero into `0 / 0 = nan`, so the guard protects the value and not the gradient; quiet for `numpy.where`, for a comparison against a number above 1, for a floor named `eps`, `tol` or `floor` on the other side, and once `d` is re-bound to a `where`, `clamp` or `maximum` of itself (kornia #5579, found by the kornia conventions audit) |
 | `clamp-at-singularity` | medium | `clamp(x, min=0).sqrt()`, `sqrt(clamp(x, min=0))`, `clamp(c, -1, 1).acos()`: the bound is the point where the next function has an infinite derivative, and clamp's derivative at its own bound is not the same across torch versions, 1 on 2.5.1 and 2.9.1 and 0 on 2.14, so the gradient there is `inf` or `nan` on the older half of a supported range; a bound strictly inside the domain, `min=1e-8`, is a floor and is not reported, and `numpy` is quiet (kornia #4229, found by the kornia conventions audit; kornia #5500) |
+| `dropout-never-applied` | medium | a `Dropout`, `DropPath` or a `ModuleDict` of them assigned to `self` and then never called, never passed on and its rate never read, anywhere in the file: the option is accepted and does nothing, so the model trains without the regularisation it reports (peft #3830) |
 
 On kornia `main` at `e05b0ee` the scan takes 4 s for 506 files and reports 35 findings. The
 `one-minus-cos` and `small-angle-division` findings are the four lines of `So3.right_jacobian` and
@@ -255,6 +257,19 @@ report seven lines: three `clamp` bounds in `_solve_cubic_real`, and four `where
 boxes and polygons. On ultralytics `main` at `8df3534` they report three lines, all in metrics or
 inference code that is never differentiated, and nothing in torchvision.
 
+`dropout-never-applied` reads the whole file rather than one function, since the module is built
+in `__init__` and used, if at all, in `forward` or in a sibling class. Calling it, calling it
+through a subscript, passing it to another module, returning it, iterating over it and reading
+its rate (`scaled_dot_product_attention(dropout_p=self.dropout.p)`) all count as use; filling it
+(`self.oft_dropout.update(...)`) does not, and a subclass of `Sequential` runs every attribute and
+is not read. On kornia `main` at `6d579a72`, ultralytics `6d51b7e`, torchvision `9a8d545`,
+diffusers `d961a38`, torchrl `648f50c`, vllm `73c742b` and detectron2 `1e3e13b` it reports
+nothing. On peft `main` at `f6d8480` it reports `OFTLayer.oft_dropout`, which is #3830; on timm
+`83e6eb5` it reports `FactorAttnConvRelPosEnc.attn_drop` in `coat.py`, which a comment on that
+line already calls unused; on transformers `9167f73` it reports nine lines, four of them in
+modular files whose `forward` is inherited from another file, which the rule cannot see, and
+five attention, embedding and head dropouts built in `__init__` and used nowhere in their file.
+
 `--run` adds the dynamic half. The module level functions with the most elementary math are
 imported and called with the same 91 point grid (both signs of `1e-8` to `1e3`, and zero) for every
 required argument, in float32 and in float64, torch first and numpy second, and the float32 result

{ulpwise-0.3.3 → ulpwise-0.3.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "ulpwise"
-version = "0.3.3"
+version = "0.3.4"
 description = "Numerical conformance testing for ML code: float edge values, exact rounding oracles, knife-edge finders and a pytest plugin"
 readme = "README.md"
 license = { text = "MIT OR Apache-2.0" }

{ulpwise-0.3.3 → ulpwise-0.3.4}/python/ulpwise/__init__.py

@@ -30,7 +30,7 @@ from ._core import special as _special_core
 from ._core import ulp_distance as _ulp_distance_core
 from ._core import ulp_distances as _ulp_distances_core
 
-__version__ = "0.3.3"
+__version__ = "0.3.4"
 
 __all__ = [
     "UNARY_OPS",

{ulpwise-0.3.3 → ulpwise-0.3.4}/python/ulpwise/corpus/cases.json

@@ -143,6 +143,25 @@
    },
    "before_fix": "TypeError: cannot pickle 'module' object"
   },
+  {
+   "id": "torchrl-4504-multicategorical-to-one-hot-batched-spec",
+   "repo": "pytorch/rl",
+   "pr": 4504,
+   "merged_at": "2026-10-07T10:30:35Z",
+   "kind": "crash",
+   "title": "MultiCategorical.to_one_hot crashed for a spec with a batch shape and for the scalar sample of a shape [1] spec",
+   "symptom": "to_one_hot iterated over self.nvec, which is a 2-D tensor for a spec with a batch shape, so one_hot received a tensor as num_classes and raised TypeError; a shape [1] spec returns 0-D samples and val[..., i] on them raised IndexError.",
+   "requires": [
+    "torch",
+    "torchrl"
+   ],
+   "fixed_in_release": null,
+   "repro": "import torch\nfrom torchrl.data import MultiCategorical\nspec = MultiCategorical([3, 2], shape=(4, 2))\nhot = spec.to_one_hot(spec.rand())\nscalar = MultiCategorical([5]).to_one_hot(torch.tensor(3))\nactual = [list(hot.shape), hot.dtype == torch.bool, int(hot.sum()), list(scalar.shape), int(scalar.sum()), bool(scalar[3])]\nexpected = [[4, 5], True, 8, [5], 1, True]\n",
+   "check": {
+    "type": "equal"
+   },
+   "before_fix": "TypeError: one_hot(): argument 'num_classes' (position 2) must be int, not Tensor for the batched spec; IndexError: too many indices for tensor of dimension 0 for the scalar sample"
+  },
   {
    "id": "timm-2786-mars-last-grad-aliasing",
    "repo": "huggingface/pytorch-image-models",

{ulpwise-0.3.3 → ulpwise-0.3.4}/python/ulpwise/scan.py

@@ -136,6 +136,12 @@ RULES = {
         "take the value from the real argument and the gradient from a safe one, f(where(at_bound, safe, x)) with the value fixed up by where, or atan2 instead of acos for an angle",
         "kornia #4229 (found by the kornia conventions audit), _cdist's clamp(min=0.0).sqrt() gave nan gradients for identical float16 descriptors on torch 2.5.1; kornia #5500, clamp(-1, 1).acos() in angle_error_mat had a -inf backward at exactly 0 and 180 degrees on torch 2.5.1",
     ),
+    "dropout-never-applied": (
+        "medium",
+        "a Dropout, DropPath or a ModuleDict of them is assigned to self and then never called, never passed on and its rate never read, anywhere in the file: the option is accepted and does nothing, so the model trains without the regularisation it reports and every training forward of one input agrees",
+        "apply it in forward, or hand its rate to the function that does (scaled_dot_product_attention(dropout_p=self.dropout.p)), or drop the argument so the caller learns it is not supported",
+        "peft #3830, OFTLayer built module_dropout into self.oft_dropout and never called it, so module_dropout=0.5 trained like 0",
+    ),
 }
 SEVERITY_ORDER = {"high": 0, "medium": 1, "info": 2}
 
@@ -653,6 +659,79 @@ def python_files(root: str, include_tests: bool = False) -> List[str]:
     return out
 
 
+DROPOUT_CLASSES = re.compile(r"^(Dropout\w*|AlphaDropout|FeatureAlphaDropout|DropPath|StochasticDepth|DropBlock\w*)$")
+DROPOUT_NAMES = re.compile(r"drop_?out|drop_?path|stochastic_?depth|drop_?block", re.I)
+DROPOUT_HOLDERS = {"ModuleDict", "ModuleList", "Identity"}
+RATE_ATTRS = {"p", "prob", "rate", "drop_prob", "drop_rate", "dropout_p", "dropout", "drop_path_rate"}
+
+
+def _dropout_like(value: ast.AST, attr: str) -> bool:
+    """Whether ``self.<attr> = value`` builds a dropout: a Dropout-class call, either branch of a conditional
+    expression, or a ModuleDict, ModuleList or Identity under a name that says dropout (filled in later)."""
+    if isinstance(value, ast.IfExp):
+        return _dropout_like(value.body, attr) or _dropout_like(value.orelse, attr)
+    if not isinstance(value, ast.Call):
+        return False
+    name, _ = _callee(value)
+    if name is None:
+        return False
+    return bool(DROPOUT_CLASSES.match(name)) or (name in DROPOUT_HOLDERS and bool(DROPOUT_NAMES.search(attr)))
+
+
+def _applied(node: ast.Attribute, parents: dict) -> bool:
+    """Whether this read of ``self.x`` uses the module: a call, a call through a subscript, an argument, a return
+    or yield, an operand, a loop target, an alias to a local, or a read of its rate. Assigning to it, filling it
+    (``self.x.update(...)``, ``self.x[k] = ...``) and reading other attributes of it are not uses."""
+    parent = parents.get(node)
+    if isinstance(parent, ast.Subscript) and parent.value is node:
+        node, parent = parent, parents.get(parent)
+    if isinstance(parent, ast.Call):
+        return parent.func is node or node in parent.args or any(k.value is node for k in parent.keywords)
+    if isinstance(parent, ast.Attribute):
+        return parent.attr in RATE_ATTRS
+    if isinstance(parent, ast.Assign):
+        return parent.value is node
+    if isinstance(parent, (ast.AnnAssign, ast.AugAssign)):
+        return parent.value is node
+    if isinstance(parent, ast.For):
+        return parent.iter is node
+    return isinstance(parent, (ast.Return, ast.Yield, ast.BinOp, ast.Compare, ast.IfExp, ast.Tuple, ast.List,
+                               ast.Dict, ast.Starred, ast.keyword, ast.FormattedValue, ast.Await, ast.BoolOp))
+
+
+def _dropouts_never_applied(tree: ast.Module, path: str, source_lines: Sequence[str]) -> List[Finding]:
+    """The ``dropout-never-applied`` rule: a file-level pass, since the module is built in one method and used, if
+    at all, in another, or in a sibling class of the same file. Subclasses of ``Sequential`` run every attribute
+    in order and are not read."""
+    parents: dict = {}
+    for node in ast.walk(tree):
+        for child in ast.iter_child_nodes(node):
+            parents[child] = node
+    used: set = set()
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Attribute) and _applied(node, parents):
+            used.add(node.attr)
+    findings: List[Finding] = []
+    for cls in ast.walk(tree):
+        if not isinstance(cls, ast.ClassDef) or any(ast.unparse(b).endswith("Sequential") for b in cls.bases):
+            continue
+        for fn in cls.body:
+            if not isinstance(fn, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                continue
+            for node in _own_nodes(fn):
+                if not (isinstance(node, ast.Assign) and len(node.targets) == 1):
+                    continue
+                target = node.targets[0]
+                if not (isinstance(target, ast.Attribute) and isinstance(target.value, ast.Name)
+                        and target.value.id == "self"):
+                    continue
+                if target.attr not in used and _dropout_like(node.value, target.attr):
+                    qualname = cls.name + "." + fn.name
+                    findings.append(Finding("dropout-never-applied", path, node.lineno, qualname,
+                                            source_lines[node.lineno - 1].strip()[:160]))
+    return findings
+
+
 def scan_source(source: str, path: str = "<string>") -> Tuple[List[Finding], List[HotSpot]]:
     try:
         with warnings.catch_warnings():
@@ -669,6 +748,7 @@ def scan_source(source: str, path: str = "<string>") -> Tuple[List[Finding], Lis
         findings.extend(f)
         if spot.calls:
             spots.append(spot)
+    findings.extend(_dropouts_never_applied(tree, path, lines))
     return findings, spots
 
 

{ulpwise-0.3.3 → ulpwise-0.3.4}/tests/test_scan.py

@@ -165,6 +165,17 @@ SNIPPET = textwrap.dedent(
         e = (-(x.pow(2))).exp()
         f = torch.exp(-torch.square(x))
         return a, b, c, d, e, f
+
+
+    class Unregularised(torch.nn.Module):
+        def __init__(self, dim, p):
+            super().__init__()
+            self.proj = torch.nn.Linear(dim, dim)
+            self.attn_drop = torch.nn.Dropout(p)
+            self.proj_drop = torch.nn.Dropout(p)
+
+        def forward(self, x):
+            return self.proj_drop(self.proj(x))
     '''
 )
 
@@ -182,6 +193,7 @@ EXPECTED = {
     ("acos-for-angle", "angle_between"),
     ("eps-floor", "one_hot_floor"),
     ("eps-floor", "Smoother.forward"),
+    ("dropout-never-applied", "Unregularised.__init__"),
     ("one-minus-cos", "so3_jacobian"),
     ("small-angle-division", "so3_jacobian"),
     ("where-nan-gradient", "so3_jacobian_guarded"),
@@ -215,6 +227,88 @@ def test_every_rule_fires_once_on_its_snippet_and_the_guard_silences_it():
     assert busiest.function == "misc" and busiest.calls == 7 and "exp" in busiest.names
 
 
+DROPOUTS = textwrap.dedent(
+    '''
+    import torch
+    from torch import nn
+    import torch.nn.functional as F
+
+
+    class Attention(nn.Module):
+        def __init__(self, dim, p):
+            super().__init__()
+            self.dropout = nn.Dropout(p)  # its rate is read and handed to the kernel
+
+        def forward(self, q, k, v):
+            p = self.dropout.p if self.training else 0.0
+            return F.scaled_dot_product_attention(q, k, v, dropout_p=p)
+
+
+    class Block(nn.Module):
+        def __init__(self, dim, p, drop_path):
+            super().__init__()
+            self.drop_path = DropPath(drop_path) if drop_path > 0.0 else nn.Identity()  # never applied
+            self.drop = nn.Dropout(p) if p > 0.0 else nn.Identity()
+            self.mlp = Mlp(dim, drop=self.drop)  # passed on
+
+        def forward(self, x):
+            return x + self.mlp(x)
+
+
+    class Mlp(nn.Sequential):
+        def __init__(self, dim, drop):
+            super().__init__()
+            self.fc = nn.Linear(dim, dim)
+            self.drop = nn.Dropout(0.5)  # a Sequential runs every attribute
+
+
+    class Adapters(nn.Module):
+        def __init__(self):
+            super().__init__()
+            self.lora_dropout = nn.ModuleDict({})  # filled and called through a subscript
+            self.oft_dropout = nn.ModuleDict({})  # filled and never called
+
+        def update_layer(self, name, p):
+            self.lora_dropout.update(nn.ModuleDict({name: nn.Dropout(p)}))
+            self.oft_dropout.update(nn.ModuleDict({name: nn.Dropout(p)}))
+
+        def forward(self, x, name):
+            return self.lora_dropout[name](x)
+
+
+    class Head(nn.Module):
+        def __init__(self, dim, p):
+            super().__init__()
+            self.dense = nn.Linear(dim, dim)
+            self.dropout = nn.Dropout(p)  # applied by a sibling class of this file
+            self.drops = nn.ModuleList([nn.Dropout(p) for _ in range(2)])  # iterated
+
+        def forward(self, x):
+            for drop in self.drops:
+                x = drop(x)
+            return x
+
+
+    class Wrapped(nn.Module):
+        def forward(self, x):
+            return self.inner.dropout(self.dense(x))
+    '''
+)
+
+
+def test_dropout_never_applied_reads_the_whole_file_and_knows_the_ways_a_module_is_used():
+    findings, _ = scan.scan_source(DROPOUTS, "dropouts.py")
+    assert [(f.function, f.line) for f in findings if f.rule == "dropout-never-applied"] == [
+        ("Block.__init__", 20),
+        ("Adapters.__init__", 39),
+    ]
+    assert findings[0].snippet.startswith("self.drop_path = DropPath(drop_path)")
+    assert findings[1].snippet.startswith("self.oft_dropout = nn.ModuleDict({})")
+    # a float rate is not a module, and a function is not a class
+    quiet = scan.scan_source("class A:\n    def __init__(self, p):\n        self.dropout = p\n\ndef f(self):\n    self.dropout = Dropout(0.1)\n", "q.py")[0]
+    assert not quiet
+
+
 def test_scan_is_quiet_about_the_escape_sequences_of_the_scanned_file():
     source = 'import torch\n\n\ndef f(x):\n    return "\\%" + str(torch.exp(x))\n'
     with warnings.catch_warnings():