Most teams decide how an image is normalised exactly once, at ingest, and then never revisit it. The decision is made by whoever wrote the loader, it is inherited by every model that reads the archive, and it is invisible in every experiment afterwards because it has stopped looking like a decision at all. On a roughly twenty-month engagement with a mid-sized Middle East carbonate operator, that quiet default would have been the single most expensive line of code nobody wrote on purpose. This piece is not an argument about which normalisation of a borehole-image log is better. It is an argument about the process that decides, and specifically about why representation choice has to be run as a controlled per-task ablation baked into the pipeline rather than inherited as a property of the dataset.
The evidence that forces the point is a reversal we cover in full elsewhere, so here it is one paragraph. Two models read the same 14-well set of borehole-image logs. The fracture-and-bedding detector wanted the dynamic, moving-window contrast normalisation and rejected the static one; the vug detector wanted the raw static log and rejected dynamic. Same rock, same measurement, same pixels, opposite verdicts, because dynamic contrast lifts planar features and a fracture is a plane while a vug is a conductive blob for which those same amplified planes are noise. If you want the fracture side derived, see Static vs Dynamic Image Logs: A 25x Class-Error Drop from Data Choice Alone; if you want the vug side, see Static Beats Dynamic: Why We Threw Away the Nicer Image Log for Vug Detection. Take the reversal as established. The rest of this piece is about what a reversal like that does to your process.
The default is a decision you stopped auditing
A shared preprocessing front-end feels like reuse. Two tasks read the same archive, so they read it through the same loader, and the normalisation baked into that loader is applied to both without a second thought. The saving is real for engineering effort and completely illusory for correctness. What actually happened is that a choice with a first-order effect on accuracy was made for the second task by the person who built the first task, on evidence that only ever concerned the first task.
The reason this is dangerous is that the default carries no signal about its own validity. When a model trained on the inherited representation underperforms, nothing in the run points at the representation. The loss curves look like a modelling problem, so the team reaches for a modelling fix: a deeper backbone, a different loss, more augmentation, more epochs. Every one of those is a plausible lever, every one of them costs time, and none of them can recover a signal the input representation has already destroyed. The default failed silently, and it failed upstream of everything the team is now tuning.
On this engagement the silent-failure direction ran both ways at once, which is what makes it a clean illustration rather than a one-off. Inherit dynamic because the fracture model liked it, and the vug detector inherits a representation that amplifies fractures into false positives. Standardise on static because the vug detector needs it, and the fracture model inherits a representation that flattens the exact sinusoid it has to regress. There is no default that is safe for both. Any team that picks one and reuses it has silently accepted a large accuracy loss on whichever task it did not pick for, and the pipeline will never tell them.
The gate: re-open the representation before the architecture
The fix is procedural, and it is cheap relative to what it saves. Every new detection target clears one gate before anyone touches the model: run the representation choice as a controlled ablation on that target, with everything else held fixed, and let the target's own metric pick the winner. Dynamic against static, one variable changed, same split, same budget, same everything else. The output is not a preference; it is a measured verdict for that specific feature, and it becomes the representation that task ships on.
Three properties make this a gate rather than a suggestion. It runs per target, not per dataset, because the archive is shared but the right representation is not. It runs before architecture work, because the representation bounds what any architecture can recover and there is no point tuning a backbone against an input that has thrown the signal away. And it is a controlled single-variable ablation, not an eyeball comparison, because the whole reason the reversal is trustworthy is that it was measured with everything else frozen. On this engagement the fracture-side verdict came out of exactly that discipline: the static-versus-dynamic swap, with the model and recipe held fixed, and the effect was large enough to sit alongside the other first-order sweeps we ran the same way, the well-count sweep and the augmentation on-off sweep.
The gate has a second, quieter job beyond picking a winner. It documents the choice. A representation that survived a per-task ablation is recorded as a verdict with a number attached, not as an unexamined inheritance, so the next person who reads the pipeline can see that the question was asked and answered for this target. That record is what stops the default from silently propagating to the next task down the line.
Enhancement is chosen the same way, not borrowed
The gate does not stop at the static-versus-dynamic fork. Once a task has its base representation, any enhancement layered on top faces the same discipline: it is chosen against the target, not inherited from the sibling task that happened to share the archive. On the vug side, static alone left a real gap, because a globally scaled image lets a blob in a locally dark zone fall below any single threshold. The wrong reflex is to reach back for dynamic to recover local sensitivity. The disciplined move is to build a task-specific enhancement that adds local variation without re-amplifying the planar contrast the base choice was made to suppress, and to check that it holds its own constants across every well rather than being retuned per image. The construction of that enhancement lives in Five Images from One Log: Top-K Mode Subtraction and is not re-derived here; the process point is only that enhancement is a second per-task choice, gated the same way as the first, not a knob borrowed from whichever task won last.
The general shape is that preprocessing is not one decision but a small chain of them, and every link is a per-target choice with a measured justification. The failure mode is treating any link in that chain as a dataset constant. A team that ablates the base representation but then borrows the enhancement from a neighbouring task has re-opened exactly the door the gate was built to close.
How to tell a team has skipped the gate
The tell is architectural, not statistical, and it is easy to spot in a code review. If a new detection task shares a preprocessing path with an older one for no reason other than that they read the same logs, the shared normalisation is an untested assumption wearing the costume of reuse. There is no ablation on record for the new target, no verdict with a number, only an inheritance. That is the signature of a skipped gate, and it is present whether or not the new task happens to be underperforming, because a default can be wrong and lucky at the same time.
The correction is to treat every shared-preprocessing link between two tasks as owing a per-task ablation before it is trusted. If the ablation was run and the shared choice won on its own merits, the sharing is earned and the record proves it. If no ablation was run, the sharing is a liability the pipeline is hiding, and the fact that it has not visibly hurt yet is not evidence that it will not. The discipline is not "prefer static" or "prefer dynamic." It is that no representation ships to a new target without having been the winner of a controlled ablation on that target, and that the pipeline is built so this is a gate a task must pass rather than a habit a team might remember.
Key takeaways
- The load-bearing claim is about process, not physics: representation and preprocessing choice must be run as a controlled per-task ablation baked into the pipeline, never inherited as a fixed front-end from the dataset.
- A shared preprocessing default fails silently. It carries no signal about its own validity, so an inherited representation that has thrown the signal away reads as a modelling problem, and the team spends on backbones and losses that cannot recover it.
- On one 14-well set the default was unsafe in both directions at once: inherit dynamic and the vug detector drowns in fracture false positives; standardise on static and the fracture model flattens the sinusoid it must regress. No single default is correct for both.
- Institutionalise it as a gate: every new detection target runs static-versus-dynamic as a single-variable ablation, on that target's own metric, before anyone touches the architecture, and the winning representation ships with a recorded verdict.
- The tell of a skipped gate is a task sharing a preprocessing path with another only because they read the same logs, with no ablation on record. Enhancement layered on top is a second per-task choice, gated the same way, not a knob borrowed from the sibling task.
Limitations
This is a process argument built on one engagement's evidence, and the two verdicts that motivate it come from two different model families, a detection transformer for fractures and a classical threshold-and-contour pipeline for vugs, so the reversal is a comparison across two tasks and their fitted pipelines rather than a controlled swap inside a single model. That is enough to establish that a shared default can be wrong, which is all the process argument needs, but it is not a portable benchmark for the size of the effect on any other archive. The fracture-side class-error figures come from an ablation on this operator's 14-well carbonate set and should be read as evidence for the direction of the effect on planar features, not as a number to expect elsewhere. The gate as described assumes you can run a single-variable ablation cheaply enough to make it a standing step; on a task where labelling or training is expensive, the per-target ablation still has to happen, but its cost has to be planned for rather than assumed away. The claim generalises past borehole-image logs only as far as the underlying condition holds: that one measurement admits more than one representation and the right one depends on the feature. Where a task has only one sensible representation, the gate is a quick check that finds nothing, which is the correct outcome, not a wasted step.
References
[1] Static vs Dynamic Image Logs: A 25x Class-Error Drop from Data Choice Alone. Earthscan insight. https://www.earthscan.io/insights/static-vs-dynamic-image-logs-class-error
[2] Static Beats Dynamic: Why We Threw Away the Nicer Image Log for Vug Detection. Earthscan insight. https://www.earthscan.io/insights/static-beats-dynamic-vug-detection
[3] Five Images from One Log: Top-K Mode Subtraction. Earthscan insight. https://www.earthscan.io/insights/top-k-mode-subtraction-vug-isolation
