Skip to main content
EarthScan

Research &
Blog

In our AI labs, we're innovating to revolutionize subsurface geology, aiming to build an actionable, results-driven AI to unlock Earth's resources and optimize drilling success. Dive into our groundbreaking research and business insights here.

The Subsurface Data Paradox: Why Oil & Gas Is Sitting on AI's Richest Training Ground

The oil and gas industry holds decades of high-resolution subsurface data — the richest structured dataset for training foundation models — yet lags consumer tech in AI adoption. Three structural shifts are closing that gap.

Qatar's 142 MTPA Bet on Getting AI Right Inside the Plant

QatarEnergy LNG runs one of the most comprehensive enterprise AI deployments in global LNG—and doubled down in May 2025.

From 40-Fold to 4,000-Fold: How Data Density Is Reshaping Geophysics and Machine Learning

Seismic data fold has jumped from ~40 to over 4,000 in two decades — a hundred-fold increase that is fundamentally changing what machine learning can do in subsurface science, shifting the human role from execution to lateral thinking, and opening frontiers beyond Earth.

Basin-Targeted Seismic Foundation Models: Why Region-Specific Pretraining Wins

A family of masked-autoencoder foundation models pretrained on ~30 TB of Norwegian Continental Shelf seismic data outperforms generic vision models and a globally pretrained seismic baseline across four interpretation benchmarks — with the 2.5D multi-view variant emerging as the practical default.

The 2026 Reset: Why Subsurface AI Is Now a Survival Layer, Not a Pilot

The 2026 oil and gas downturn is a permanent recalibration of the human-to-machine ratio. Operators who digitalised before the workforce cuts are already pulling ahead — and the gap is structural, not cyclical.

Seismic Foundation Models: The CDO's New Edge

Operators spend $2.4B/year on subsurface studies that take weeks. Seismic foundation models compress that to hours — and put the CDO in charge.

Agentic CCS: Months of Site Screening in Minutes

A five-agent orchestrated loop screens 10 synthetic North Sea / Gulf Coast wells against CCS reservoir-caprock criteria in under 2 seconds.

Why the Next Energy Majors Will Be AI Infrastructure Operators

Most energy AI pilots never reach production — and the reason isn't the data science, it's that nobody owns the compute. The operators that own their HPC layer, their data, and their models will define the next decade of upstream competition.

GeoBFDT: A Transformer for Automated Bedding and Fracture Detection in Borehole Image Logs

A research note on GeoBFDT, a DETR-style transformer trained on two different microresistivity imaging tools across 14 wells, that detects fractures and bedding planes end-to-end — predicting depth, dip, and azimuth without mask supervision.

Oil & Gas in 2026: From AI Customer to AI Builder

In 2026, oil and gas stopped buying AI off the shelf and started building it — sovereign LLMs trained on decades of subsurface data, agentic stacks replacing upstream workflows, and modular data centers next to refineries. The same industry is now the power supply for the hyperscaler buildout. Two flows of capital, one tape.

Beyond the wellbore: an AI feasibility note on lignin and bio-inspired materials

Most of EarthScan's published work sits in the wellbore. This research note covers a parallel thread — applying deep learning to the second-most-abundant biopolymer on Earth, the structurally complex feedstock that has been chronically under-utilised in the energy transition.

Pricing a Senior AI Bench: Day-Rate Ladders, Academic Discounts, and the Equity Option

How a small lab priced a 644-man-day AI bench and held an academic-discount lever in reserve to underbid Big-4 consulting. The commercial workbook carried two ladders side by side: the Berlin/Paris commercial day rate the bench was actually priced at, from 3,200 down to 800 EUR, and an academic rate near half of it at every tier, 1,600 down to 480. Priced at commercial rates, the full bench totalled 869,472 EUR, or 1,350 EUR a day blended (956,419.20 with a 10 percent contingency); a leaner 484-man-day build came to 701,472 (771,619.20 with contingency). Re-priced tier for tier on the academic ladder, the same bench falls to roughly 435,000 EUR, near 676 EUR a day. Compute was owned, not rented, at 700 and 1,500 EUR a month per GPU server. And one clause offered a further discount below even the academic rate in exchange for equity or shared revenue. This is the anatomy of a senior bench priced with a discount lever built in.

From Picks to Permeability: What Automated Fracture Detection Is Actually For

An automated fracture picker is often sold as the deliverable, but in a fractured carbonate the reservoir permeability rides on fracture aperture and density, not on matrix porosity, so a pick is only the front of a value chain. This survey traces the published petrophysics that sits between a detection and a completion decision: the single-fracture relation K = 5e7 w2 that makes permeability go as the square of aperture, the C = 250/80 connectivity constant from the Marun-field permeability study, and the Luthi-Souhaite aperture equation with its validated 1 to 1000 md index range from Aghli 2020, with 80 to 400 md carried as a matrix-permeability reference from the clean sandstone zones of the same Marun study, not as a fractured-carbonate band. We use those numbers to argue that the value of an AI pick is set downstream: a density log, an aperture, a permeability profile, and only then a decision on where to perforate. The imaging tool bounds the whole chain, since FMI carries 192 buttons for about 80 percent borehole coverage against EMI's 150 buttons for about 60 percent, and the competitor benchmark of a conditional GAN reporting 90 percent accuracy on horizontal and low-angle fractures shows that even stage one is contested. Why the aperture step itself is unreliable is the subject of a companion piece; here the emphasis is the chain, what a pick is for. The central claim is that detection accuracy is necessary but not sufficient, because the number an engineer acts on is a permeability, and permeability is an aperture problem.

The 96-Hour SLA: Designing Client-Approval Deadlines Into an AI R&D Contract

In most software contracts the response-time SLA is a vendor promise: reply within N hours or pay a penalty. On an applied-research engagement with a major operator in Oman, we wrote it the other way round. The client owed the data, the approvals, and the platform access, so a 96-hour client-approval deadline went into the contract and was paired with milestone-tranche invoicing. This is a short read on why the response-time clock belongs on the party who controls the inputs, and how the two mechanisms together kept a three-year research programme from stalling on sign-off.

The 502-Page Receipt: Auto-Generated Per-Metre QC Reports That Make AI Picks Auditable

A prediction is easy to distrust and hard to check. So for a vug-detection run over a 251 m carbonate interval, the deliverable we shipped was not a vug percentage. It was a 502-page document, machine-written in seconds, that gives every metre its own two-page dossier: a run id, the exact parameter table the detector used, a raw/binary/overlay image triplet, a per-decimetre vug percentage, a per-vug table down to the pixel centroid, and, where the detector found nothing, an explicit page that says so. In a regulated technical domain the thing a reviewer can act on is not the pick but the audit trail behind it, and the empty pages are the part that proves the trail is complete.

Effort Obligations and a Liability Cap: Contracting AI R&D So Both Sides Survive Failure

A subsurface AI research contract is a bet that can lose. The document we signed with a major operator in Oman was drafted so that a lost bet would not ruin either side: an effort-not-result obligation, phase-gated payments with exit rights, a hard USD 10,000 liability cap, provider-retained IP, and a customer data-quality warranty that turned out to matter when a missing data column stalled the model. Publication rights were fixed at proposal stage. This is the procurement-and-legal shape a standard software MSA gets wrong, read clause by clause.

Under 10 Seconds for Five Metres: Re-Substantiating the Speed Claim for AI Borehole Interpretation

A speed number is a promise, and the wrong one gets you into trouble in review. An earlier version of this work quoted a vug-processing figure of about 30 seconds per metre, and a reviewer withdrew it because the comparison behind it was unfair. That number was never the fracture and bed model's to quote. The figure that model can defend, and that we put on a conference poster, is different and cleaner: under 10 seconds to interpret a 5 metre section, end to end. This piece walks the honest speed math for that claim, states plainly what the 10 seconds does and does not include, and sets it against the two things it replaces: a semi-automatic prior-art system that only reached days to hours, and a classical-computer-vision baseline of 5 minutes per metre. The point is which number is defensible, not which number is largest.

What Enterprise AI Upskilling Actually Costs Per Head

The Omanization pieces argued that building local AI talent pays back. None of them priced it. This one does, from a real training-programme proposal we wrote: a per-participant number that runs from 26,500 EUR at a junior-analyst tier to 146,500 EUR at a professional-data-scientist tier, with the honest build-up underneath - cloud compute per learner, mentor days across 120 to 200 offsite days, assessment, travel. The instrument lets you drag across the tiers and watch the stack grow by an order of magnitude.

What a EUR 86k Subsurface-AI Pilot Actually Buys: Line-Item Anatomy of a 2020 Engagement

A buyer who has only ever seen seven-figure consultancy quotes assumes a subsurface-AI pilot is priced the same way: a lump, defended by reputation, impossible to audit. Our 2020 proposal to a major operator in Oman was the opposite. EUR 85,945 for two phases over ten months, decomposed into a 20 percent mobilisation invoice of EUR 17,189, six travel trips at EUR 2,000 each, cloud at EUR 3,000 a month for two dedicated EU servers, EUR 300 a month for repos, EUR 700 a month for tooling, a 96-hour approval SLA, and a small remainder. This post reads the price line by line to show a pilot is a knowable, budgetable object, not a black box.

The Aperture Trap: Why Image-Log Fracture Apertures Are Unreliable, and What to Report Instead

Vendor interpretation reports quote a fracture aperture in millimetres, and a number in millimetres reads like a measurement. It is mostly an inference, and a fragile one. The aperture comes from the Luthi-Souhaite relation, which the vendor's own report flags as unreliable in high-resistivity-contrast zones, and image logs are known to exaggerate the width of any fracture thinner than 0.1 mm, so a hairline crack can be reported an inch wide. We argue that an automated borehole-image picker should not chase aperture magnitude at all. It should report the two things the same tool measures robustly: fracture density and the conductive-or-resistive class of each pick. We walk through why the standard aperture equation breaks down where the rock is resistive, show the exaggeration mechanism for sub-0.1 mm cracks, and point to the density-first vocabulary (Berg's P32 method with a connectivity percolation threshold of 2.0, and the density-to-permeability chain K = 5e7 * w^2 with clean-sandstone permeability of 80 to 400 md) that an automated picker can stand behind.

Disclosing Physics to Reviewers Privately: How to Answer Technical Questions Without Publishing Client Data

A reviewer asked for the connate-water salinity and mud conductivity that set the resistivity contrast our vug detector keys on. The numbers exist, they belong to the operator, and the confidentiality agreement forbids printing them. The move that satisfied the reviewer without breaking the contract: disclose the physical parameters privately in the review correspondence, keep the field data out of the manuscript, and let the NDA storage clause define the wall between the two. A craft note on where that line actually sits.

The Self-Scrub: Two Gates Every Number Should Pass Before a Reviewer Ever Sees It

One of our numbers once left a draft because a reviewer took it apart. We would rather that never happen again, so we run our own numbers through two gates before they ship: can you state the scope in one sentence a stranger would accept, and does it trace to a source someone outside the room can find. This is the discipline, not the incident. A companion piece tells the story of the specific figure we retired, under 30 seconds per metre for vug detection; this one is about the checklist that catches the next one before it ever reaches a reviewer, and why the two figures we did keep, under 10 seconds to interpret a 5 metre section and fracture recall of 75 percent at a 5 cm depth band across 16 wells, pass both gates.

The Stress Story Your Image Logs Already Tell: Breakouts, Induced Fractures, and the Geomechanics Door Left Ajar

Every interpreted well in this carbonate engagement kept emitting a stress signal we were not being paid to read: a breakout mirror azimuth running E-W and drilling-induced fractures running NNE-SSW, which together fix the horizontal-stress orientation. Our fracture picker already detects four conductive-and-resistive fracture classes and 910 bedding dips per well; breakouts and induced fractures are one more detection class, drawn on the same image with the same geometry. Geomechanics was the ambition the 2020 proposal scoped and the executed project descoped, a mineralogy brittleness index plus a network that solved five unknowns from two caliper diameters. Because the stress azimuths are already in the labels, that door is one detection class from reopening, and this piece walks the evidence that says so.

A 15-Year Arc of Evaluation Rigor in Borehole-Image AI: From No Objective Metric to Blind-Well F1

The visible progress in borehole-image AI is usually told as a rising accuracy line, but the more honest history is a rising bar for what an accuracy number has to survive. We trace fifteen years of how the field graded itself: a 2009 paper stating plainly that no objective evaluation was possible, because there was no ground truth, and settling for one interpreter's eye; a 2020 detector reporting AUC of 98% for fractures and 90% for breakouts on roughly three hundred thousand synthetic images with a true positive counted whenever a predicted centroid landed within 50 or 150 pixels of the label; and the current bar we work to, blind-well F1 at a 5 cm depth tolerance, read off depth-tolerance confusion matrices against thresholds negotiated with the client's expert interpreter. Our own separate-Bb model scores 67% on validation and 60% on a held-out well, with 75% recall at 5 cm across 16 wells. The argument is that the falling number is the sign of progress, not the model getting worse: the test got honest. Ren et al.'s 2020 framing of borehole images as mostly 'valueless data' that belongs to no trained class is the waypoint between loose synthetic AUC and blind-well F1. The frontier is evaluation rigor, not another accuracy point.

What a Three-Phase Subsurface AI Programme Really Costs in GPU-Hours

Vendors quote a fixed price for a subsurface AI build and almost never quote a compute budget, so an operator has no way to check whether the price is defensible against what the work actually burns. We publish the compute telemetry from a three-phase programme on a mid-sized Middle East carbonate operator's borehole-image logs and turn it into the unit-economics benchmark the market lacks. Phase 1 landed on budget at 1,200 GPU-hours. Phase 2 ran 2,600 hours against a 1,200-hour budget, a 2.2x overrun, once the supervised and unsupervised tracks ran in parallel and roughly doubled the number of concurrent runs. Phase 3 forecasts 7,500 hours against 5,800 budgeted for field-scale correlation, where the concurrent-run count is projected to grow five to seven times over the pilot to a peak of 60 to 90 runs at once. Programme totals are 11,300 GPU-hours actual against 8,200 budgeted. The mechanism behind the miss is arithmetic: a single run takes 6 to 18 hours, and a phase's cost is concurrency times run-length with utilization held at 80 to 90 percent across 28 GPU-partition containers, so the overrun lands exactly where the parallel tracks doubled the concurrency. Priced against a rate card of 30, 24.60, and 17.22 US dollars per GPU-hour, that telemetry gives a number an operator can hold a quote against.

The Contingency Clause You Hope Never to Use: Budgeting for Requirements That Will Change

An R&D proposal for a subsurface AI programme carried two things most budgets leave out: an explicit contingency line, and a written sentence saying the requirements would change. Eight months in, the 2022 energy shock hit, energy prices up 400 percent and DGX-class hosting moving from USD 12-15K to over 20K a month. Because the reserve was already named and agreed, the team absorbed it as a bounded USD 51K draw inside a USD 104,300 additional request against a USD 533,000 approved budget, a 9.6 percent top-up on a line the client had pre-agreed could move, rather than an emergency contract reopening. This is how to price and phrase contingency so it reads as prudence, not padding.

The GPU-Hour Ledger: What Three Phases of Subsurface AI Actually Cost in Compute

A subsurface AI programme budgeted 8,200 GPU-hours across three phases and burned 11,300. The overrun did not land where planning intuition puts it. The data-collection phase came in exactly on budget at 1,200 hours; the supervised-model phase, the smallest allocation on the sheet, ran 2,600 against 1,200 and blew 2.2x its compute budget. This is a compute-economics post read straight from the programme's own ledger: which phase actually breaks the GPU budget, why model development and not data collection is the runaway line, and how to structure the overrun ask so a mid-engagement funding conversation does not derail the delivery.

How Much Error Is Human? Negotiating Accuracy Thresholds With the Expert Your AI Assists

Before we reported a single recall number, we sat with the client's chief interpreter and agreed what counts as a hit: 2, 4 or 6 cm of depth, 1, 3 or 5 degrees of dip. Then we made the metric deliberately harsh. This is a method piece on co-designing evaluation with the domain expert, bounded from below by the sensor's own resolution floor, so that a claim like '75% recall' means something the expert will sign.

MIG-Partitioning an A100 to Run 60 Experiments at Once

A technique note on squeezing a research bench out of a single card. During an energy-price shock that pushed our compute spend past budget, Multi-Instance GPU partitioning let one A100 fleet carry 60 to 90 concurrent training runs at 80 to 90 percent sustained utilisation, up to 28 hardware-isolated instances sharing the hardware. This is the partition-sizing rule we settled on: fine slices for a swarm of small-data runs, coarse slices for the few large ones, and how we read the tradeoff off one grid.

33 Comments That Turned a Rejected Fracture Manuscript Into a Journal Paper

Reviewer 3 of our fracture-detection paper returned five essential revisions and thirty-three additional comments. Not a rejection over method, but a slower verdict: the figures were impossible to read, the claims were not quantitative, and the parts we thought were obvious were never written down. Fixing those comments forced disclosures we had left implicit, including the indirect log set, conductive and resistive fractures, a mud-type-agnostic method, the 800-pixel patch rationale, and the 0-to-15 corruption behind a suspicious spike, plus a full methodology rebuild. This is what adversarial review did to a manuscript, comment by comment.

Publishing Peer-Reviewed AI Research Under a National-Oil-Company NDA

Two journal-bound papers and a conference abstract shipped while masking depth digits, withholding code, and partitioning data by patch rather than by well — under a strict confidentiality agreement with a Middle East carbonate operator we partnered with. The lesson: rigorous evaluation, not open data, is how confidential industry AI earns peer-review credibility.

The Reviewer Said Our Results Were Too Beautiful to Be Believed. Here's How We Answered.

A reviewer looked at Figure 9 of our fracture-detection paper, called it too beautiful to be believed, and demanded the code and data on GitHub. A confidentiality agreement made that impossible. This is the first-person account of what we added instead: failure-case figures, sensitivity tests, dip-intensity metrics, and full workflow diagrams, plus a novelty defense we would not trade away. Credible when the artifact stays closed.

The Closed-Code Wall: We Tried to Benchmark a Rival Method and Hit Silence

A reviewer asked us to compare our carbonate vug detector against a published path-morphology method. We wanted to. None of the cited studies release their code, so we ran our pipeline on a screenshot of the rival paper's figure, got comparable threshold maps, and wrote to the authors for permission and the raw data. We never heard back, and we dropped the comparison. This is what honest benchmarking looks like in an industry where nobody can publish code, including us: our own is closed under a client confidentiality agreement we asked to lift and were refused.

Vug Ratio, Not IoU: Choosing a Metric That Matches the Labels You Actually Have

A vug-quantification study for a mid-sized Middle East carbonate operator had exactly one comparator: incumbent-software vug ratios, a subjective human read with no per-vug masks, on a task that predicts a continuous ratio. That single fact about the labels ruled out the metrics reviewers reached for first. IoU needs per-vug masks the labels never held; a confusion matrix needs discrete classes on what is a regression task; a cross-plot would imply an objective truth the read cannot claim. So we relabeled the baseline 'incumbent-estimation' rather than 'ground truth' and added a two-series comparison plot in place of a cross-plot. This is a short argument for picking the metric your labels can support, and for not dressing a subjective baseline as an objective one.

Two Opposite Failure Modes, One Identical Score: Stress-Testing F1 Before Trusting It

Before we wired a single metric into model selection, we tried to break it. Two toy detections from our own error workbook say why: one model predicts 100 sinusoids against 10 real, another predicts 10 against 100 real. Precision alone crowns the first, recall alone crowns the second, and each hands its favourite a misleading 100%. F1, the harmonic mean, collapses both opposite failures to exactly 18.18%. This is a short field note on adversarially probing a domain metric with pathological cases before you let it rank models across validation and blind sets, a habit worth keeping for any custom score.

Consistent, Auditable Interpretation: Why AI Picks Beat Inter-Interpreter Variance

Two senior geologists rarely pick the same fractures and vugs on the same image log. We argue that the real prize of a computer-vision interpretation pipeline is not raw speed but determinism — the same input yields the same picks, every parameter is logged, and the model even surfaces sinusoids and vugs the expert ground truth missed. That turns interpretation from an interpreter-dependent art into a reproducible, auditable process, which is a governance win as much as a throughput one.

When the Reviewer Asks Why Not Deep Learning: Defending a Classical CV Pipeline in 2024

A reviewer asked the obvious 2024 question of our carbonate vug-quantification paper: why a hand-built computer-vision pipeline instead of a neural network. The honest answer turned the objection inside out. A literature check found no supervised regression-based vug quantifier exists, because no contour-annotated vug dataset exists to train one. So the classical pipeline is not a fallback. It is the dataset factory whose extracted contours become the masks a future model would need. This is that defence, plus the 6-universal-vs-2-calibrated parameter protocol that made the method deployable across wells.

When Your Baseline Is Not Ground Truth: Scoring AI Against Subjective Expert Software

The habit of calling the comparator 'ground truth' is usually harmless, and on this task it was a mistake. Our vug detector was being scored against a subjective software interpretation of a borehole-image log, a reading produced by one expert in one tool, with a known bias toward missing pores the detector then found. Halfway through peer review we renamed that comparator from ground truth to a borehole-image estimation, and the rename forced a change of instrument. A confusion matrix was wrong twice over: the task is a continuous vug-ratio regression, not a class label, and it reads every real pore the expert missed as a false positive. A cross-plot was wrong once: it draws a 45-degree line of objective truth that the comparator does not carry. We refused both and drew comparison overlays instead, two estimates side by side with no claim that either is correct. The choice is not a stylistic preference. It sits on a 15-year arc: the 2009 state of the art for automated fracture detection stated plainly that 'we cannot provide a truly objective evaluation, because there is no ground truth,' and evaluated by eye against a single interpreter with false picks removed by hand. This piece is about the epistemology of that scoring decision, not the detector's numbers, which we report elsewhere.

What Four Reviewer Challenges Actually Asked Us, and How We Answered Without Breaking the NDA

A line-by-line account of the vug-quantification paper's second-revision reviewer exchange: an editor doubted our generalisation, a reviewer wanted a Frechet or Hausdorff shape distance instead of our circular area ratio, another asked whether the method separates interconnected from isolated vugs, and someone wanted the connate-water and mud salinity. We defended the defaults, granted the limitation we genuinely have, and disclosed the physics privately - the honest map of what to fight and what to concede under a confidentiality agreement.

Your Ground Truth Probably Isn't: What Peer Review Taught Us About Labels From Incumbent Software

A reviewer pushed on one word in our vug-quantification manuscript, and the word was ground truth. Our reference vug percentages had not been drawn by hand; they came out of an incumbent interpretation package as area fractions, with no per-vug masks behind them. Once we admitted that on the page, two of the metrics a reader expects fell away by definition: with no masks there is nothing to intersect, so IoU is undefined, and with a continuous target there are no classes, so a confusion matrix has no cells. We renamed the baseline from GT to incumbent-estimation throughout the paper and reported vug-ratio, an interval area comparison, as the only honest score left. This is a piece about label provenance as a first-class question: when your reference comes from a tool rather than a person, you are benchmarking against software, and your metrics have to say so.

Validation Said 51%, the Blind Well Said 4%: The Error Ledger That Kept Us Honest

We kept an internal master error table that scored every fracture and bedding configuration twice: once on the validation split, once on a well the model had never touched. Read side by side, the two columns disagree so violently that the validation number is close to useless on its own. Fracture F1 at a 2 cm depth match read 50.87% on validation and 3.69% on the blind zone. A deliberately low-overlap split cut the validation number to 8.77% and it landed near the blind reality of 12.05%, which is the whole point: on scarce wells with patch-level splits, the validation set lies unless you engineer the overlap bias out of it. Beddings then fail in the opposite direction, with blind dip accuracy beating validation while blind azimuth collapses. The ledger, not the headline, is what we trusted.

From 82% on Paper to 63% Blind: An Honest Accounting of the Vertical-to-Horizontal Generalization Gap

The number a fracture-detection paper prints is its headline test F1 on vertical wells: about 82 percent at a 9 cm depth tolerance for our combined model on a mid-sized Middle East carbonate operator's borehole-image logs. The number nobody prints is what the same model family scores blind on a horizontal well it never trained near. We publish it. On a July-2023 blind run, a ResNet-18 fracture model at a 0.55 probability threshold scored precision 56.25 percent, recall 66.32 percent, and F1 60.87 percent at 6 cm, plateauing near 63 percent at 11 to 15 cm, with a depth MAE of 2.11 cm, a dip MAE of 11.12 deg, and an azimuth MAE of 65.41 deg that makes azimuth close to uninformative on horizontal wells. The gap between 82 and 63 is not a model that failed. It is expected physics: horizontal fracture sinusoids carry roughly a fifth of the amplitude of vertical ones, so the patch shrank, the ResNet backbone changed from ResNet-10 to ResNet-18, and the score dropped. We argue that plotting the gap and its mitigation ladder builds more trust than a single headline metric ever could, and that a fracture model should be judged by the distance between where it was graded and where it was blind.

The Reviewer Said Unpublishable: Anatomy of a Peer-Review Rescue for Industrial AI Research

One reviewer recommended our fracture-detection paper be rejected as unpublishable, on validation design and closed code. The editor offered a GitHub-verification remedy; a confidentiality agreement made it impossible. We reversed the vote not by arguing back but by adding three pieces of evidence under an 11,000-word ceiling: blind-well predictions from both eleven-well models, a five-horizontal-well inclination study, and a mapping that showed a head-to-head comparison was infeasible rather than refused. A playbook for defending confidential-data research.

What 2 Hours per Well Instead of 3 Weeks Actually Buys a Reservoir Team

When automated interpretation collapses fracture, bedding, and vug picking from weeks of expert labour per well to minutes, the payoff is not a smaller team. It is interpretation capacity — the scarce geoscientist hours freed for the reservoir decisions that actually move recovery.

Why We Refused to Benchmark Our Model Against YOLO and Mask R-CNN (and Were Right To)

A reviewer asked us to run a head-to-head accuracy comparison of our end-to-end fracture transformer against YOLO and Mask R-CNN. We declined, and the rebuttal we wrote turned on a distinction worth generalising: mask detectors segment fractures and then need a human to pick dip and azimuth, while our model regresses depth, dip, and azimuth directly. The two have no shared output to score, so the requested benchmark would have measured nothing. This is a short field guide to telling a meaningful benchmark from a category error.

The 98% AUC That Wasn't: What Synthetic-Data Benchmarks Hide in Image-Log AI

A widely cited prior result trained a fast-RCNN on 300,000 synthetic acoustic borehole images and reported a 98% AUC on fractures, with a true positive scored whenever a predicted box centroid landed within 50 pixels of ground truth. Our task looked adjacent but was not: real resistivity logs, sparse human picks up to 28 m apart, intersecting events in one patch, tool corruption, and a match window of 2 cm where one pixel is 3 cm of depth. On that task, blind-well fracture F1 fell from about 82% on the headline test to about 63% on a horizontal blind split. The two numbers are not comparable, because the acceptance tolerance they were computed under differs by nearly two orders of magnitude. The rigorous move is to report the blind-well and real-data metric, not the synthetic headline, and to make the tolerance visible so a reader can see which test a score actually passed.

When More Synthetic Patches Made the Model Worse: The Data-Quality-Over-Quantity Lesson for Borehole Image Logs

We augmented a thin borehole-image training set hard, ten transforms per sinusoid patch, and the corpus grew from 236 patches to 4212 and from 32 sinusoids to 3565. The class error the augmentation bought was real at first, from 100 with no augmentation down to about 2.6 with it. But the copies were re-transforms of the same 19 real sinusoid patches, so past a point the added volume amplified whatever label noise those few picks carried and deepened an already skewed sinusoid-count distribution. From the augmentation side we landed on the same conclusion our well-count ablation reached from the other direction: for carbonate borehole-image detection the binding constraint is clean, style-consistent real labels, not synthetic volume.

Separate Models for Beddings and Fractures: When Splitting the Task Beats One Detector

We trained one detection transformer to pick both beddings and fractures from borehole-image logs, and for a while that felt like the right economy: one model, one label schema, two classes. Then a well arrived whose picks prioritised fractures over beddings and left multi-metre gaps in the bedding labels, and the shared model's behaviour told us the abstraction was wrong. On the same metric axes, the two classes fail in opposite directions: beddings hold near-perfect dip accuracy but their azimuth is 22 to 23 degrees off, while fractures keep azimuth tight and give up dip. That opposition is the tell: no single regression head can serve two classes that want the loss pulled in opposite directions. The fix was to split into per-class models trained only on style-consistent wells, which dropped the beddings class error from 1.537 to 0.645.

Localisation by Design: Building Local AI Capability Inside an O&G Engagement

Capability transfer is usually filed under corporate social responsibility — a line in the sustainability report, not the business case. In a roughly twenty-month subsurface-AI engagement with a mid-sized Middle East carbonate operator we partnered with, we treated it as the opposite: 55 trained young professionals, 15 of them young national hires, were the deliverable that made a 5x throughput dividend durable. Localising AI talent is ROI, not charity.

Patch Splits or Well Splits? Evaluating Subsurface AI Honestly When You Only Have 14 Wells

A reviewer asked the sharpest question in the whole review: did our train and test splits leak? On borehole-image data from a single field, depth-adjacent patches from the same well are near-duplicates, so a shuffle can put an almost-identical neighbour on both sides of the boundary. The clean answer is to hold out whole wells. We could not. With 14 wells total, reserving even one for test costs about 7% of the corpus and destabilises every number downstream, so patch-level shuffling was the only viable split. This is the honest account of that decision: why well-level holdout was statistically unaffordable, how validation-test parity and a continuous blind zone defended the shuffle against the leakage charge, and the decision rubric other teams can use to tell when each choice is legitimate.

From R&D to Continuous AI: A Phased Operating Model for O&G AI Programs

Most oil-and-gas AI programs don't stall on the model — they stall at the handover. A Phase 0-5 operating ladder, from governance and EDA through dataset and MLOps to production CI/CD and a scale-out AI fund, gives a program a value-vs-time path. The lesson from a roughly twenty-month Middle East carbonate engagement we ran: budget the ICT transition as a phase, not a closing courtesy.

What Curve Digitisation Taught Us About Every Chart-Extraction Problem

We spent a long stretch turning scanned raster well logs into clean numeric curves, and somewhere in the middle we realised we were not really solving a well-log problem. We were solving the general problem of pulling a plotted line off a picture and turning it back into data. This retrospective abstracts our pipeline into four rungs that recur in any chart-extraction task: segment the ink, reduce each mask to a centreline, index that centreline against the axes, and validate the reconstruction on a common grid. We name which of our real results travel to other raster-to-data problems and which stay specific to a well log, using the engagement's own numbers: a peak curve-mask IoU of 0.51, a peak validation R-squared of 0.9891, a lowest mean absolute error of 0.0132, and the 300 interpolated depth points we used to compare predicted and reference curves on the same footing.

Fingerprinting Carbonate Texture: Per-Interval Vug Spectra as a Reservoir-Quality Signature

A vug detector usually reports one number per interval, a percent porosity, and one aggregate distribution for a whole well. That aggregate hides the thing an interpreter actually reads off a carbonate: how the pore texture changes with depth. This method note keeps the per-interval spectra separate and stacks about fifty of them down a single well as a ridgeline, so circularity and vug-area distributions become a continuous fingerprint of texture evolution rather than a summary statistic. The circularity spectrum sits in a 0.3 to 0.8 band with a 0.45 to 0.7 peak; vug areas cluster at 1 to 6 cm2. Alongside the ridgeline we show the reason the pipeline reports per interval at all: within a single borehole-image frame the local adaptive threshold ranges from about 0.5 to 2.5-plus, so no one global threshold survives a pad, and a 31-pixel block that covers 46.58 cm2 stepped one pixel at a time is what lets the threshold track that variation. Two genuinely new figures, one method claim.

The 15th Well Made Our Model Worse: Label Consistency Beats Data Volume

We added a fifteenth well to a fracture-detection training set that was already working, and validation F1 at 5 cm fell from about 60 percent to about 57. The well was not corrupt and the pipeline was not broken. Its ground truth had been picked with a different emphasis, fractures favoured over beddings, with pick gaps running to 175 m, so the extra rows pulled the label distribution off the style the model had settled on across the first fourteen wells. The fix was not more data but separate per-class models trained on style-consistent wells. Past a threshold, how your annotator picks matters more than how many wells you feed the network.

The Data Bottleneck Is the Real Bottleneck in Subsurface AI

A subsurface-AI program scoped for 25 annotated wells received 8. The model's largest accuracy jumps tracked the arrival of labelled wells — classification error fell from 93% at 3 wells to under 1% by 11 — not the algorithm changes the team kept shipping. For operators, data-supply governance, not model selection, is the lever that moves AI accuracy.

Sparse Labels, 28 Metres Apart: Quantifying the Annotation Density Problem in Field Image-Log AI

Synthetic image-log benchmarks assume dense, uniform ground truth: a label wherever an event exists. Real wells do not. Reading the raw expert picks from a mid-sized Middle East carbonate study, we found adjacent picks that sit up to 28 m apart, whole depth intervals with no picked sinusoids where the sampling interval alone jumps by 7, 10 and 27 m, and training patches that routinely carry about 70 intersecting sinusoids each. This note treats pick spacing as a QC signal in its own right and argues that annotation density, not label count, is the first-class dataset property that bounds which accuracy claims are even meaningful. A per-well F1 measured against a sparsely labelled well is a statement about the labelled fraction, not the well, and the two are easy to confuse when the benchmark you calibrated on was dense by construction.

Why We Trained a Detection Transformer From Scratch on Just 14 Wells

A reviewer asked us to justify a claim that reads as heresy in modern computer vision: we used no pretrained models. GeoBFDT's ResNet, transformer encoder-decoder, and losses were assembled and trained from scratch on a 236-patch, 14-well confidential dataset. This is the technique argument for that decision, and for the three coordinated disciplines it forced: no pretrained backbone, a deliberately light ResNet-10 to resist overfitting, and greater-than-tenfold augmentation, which turned out to be the single largest lever on class error.

Public Cloud vs On-Prem vs Hybrid for Confidential Subsurface AI

An infrastructure-strategy deep-dive for O&G CIOs, infra leads, and security officers. When each image log is ~1.5 GB, the training corpus is the operator's crown-jewel IP, and inference must serve an interpretation platform inside the LAN, on-prem DGX-class compute wins on both IP protection and bill-shock — with hybrid reserved for the narrow band where governance explicitly allows it.

The Number We Deleted: Retracting a Claim Mid-Manuscript

One favourable line in a peer-reviewed manuscript, on carbonate borehole image logs, claimed a detector processed under 30 seconds per metre against a four-to-five-minute baseline. A reviewer challenged it. We could not defend the number across the tools and hardware it had been measured on, so we withdrew it in revision rather than dress it up. This is a piece about what retraction inside a live manuscript actually costs, why the burden of proof sits with the author under adversarial review, and why the honest record is the one that no longer carries the claim.

Static Beats Dynamic: Why We Threw Away the Nicer Image Log for Vug Detection

For fracture picking, dynamic contrast-enhanced borehole image logs beat static ones by a wide margin. For vug detection we did the opposite: we kept the raw static log and threw away the nicer-looking dynamic one. Dynamic amplifies fractures and beddings, which is exactly the noise a vug detector must ignore, and it flattens the intensity right tail that is the vug signal. Processed-for-humans and best-for-the-model turned out to be opposites, and the mud physics says which is which.

The Sign of the Difference: How One Minus Sign Tells a Dissolution Pore From Its Mineral Look-Alike

An absolute value nearly shipped a false positive. Our vug detector's contrast test measured how far a candidate's interior sat from the rock around it, but the magnitude alone kept a bright, opposite-polarity mineral that looked exactly like a conductive pore. The fix was to stop taking the absolute value and read the sign of the mean-difference instead: negative under water-based mud marks a genuine pore, positive marks the mineral that mimics it. This is the physics of why that sign flips with mud type, why one minus sign separates two mineral classes shape never could, and where the test stops being safe.

Ablate the Representation Per Task: Making Preprocessing Choice a Standing Pipeline Gate, Not a Dataset Default

On one 14-well borehole-image set, two detection tasks reached opposite preprocessing verdicts, so the same normalisation that a dataset would hand down as a default was correct for one task and actively wrong for the other. This piece is not about which representation wins. It is about the process failure that lets a team never find out: inheriting the ingest-time normalisation as a fixed front-end instead of re-running it as a controlled per-task ablation. We describe how to institutionalise representation choice as a standing gate a new detection target must clear before anyone touches the architecture, what skipping that gate silently costs, and how to detect a team that has skipped it.

Build vs Buy: When an Operator Should In-House Dip Interpretation Instead of Paying a Service Company

Once an in-house picker runs at roughly 30 seconds per metre and 5x faster than manual interpretation, the build-vs-buy maths against paid service-company dip interpretation flips. The real gate is not model novelty — it is data access and MLOps maturity. Here is how to tell which side of the line your operation sits on.

Why ImageNet Weights Are Useless Underground: Training a Detector From Scratch on Borehole Textures

The default move on any vision problem is to load a pretrained backbone and fine-tune. On micro-resistivity borehole imagery we deleted that step entirely and trained a light ResNet-10 from scratch, because features learned on natural images do not describe a sinusoid unrolled from a grayscale cylinder. The backbone ablation makes the point brutally: the deepest net was the worst, by an order of magnitude, because with no pretrained weights to lean on, depth only buys room to overfit fourteen wells.

Edge and Quantized Inference for Field Operations: CPU Versus GPU Serving

A cross-industry assessment of running heavy segmentation models where the accelerator is not. We survey the published evidence on quantized CPU serving versus GPU serving for vision and dense-prediction models, and read it against the constraint that defines subsurface work: the data, and often the inference, must stay inside an air-gapped network where no GPU is provisioned. We credit the post-training and quantization-aware methods that made low-bit CPU inference viable, the runtimes that execute them, and the studies that measured the latency and footprint each buys, then place them on a common latency-versus-cost frontier. The organising claim is that for a wide, variable-size encoder decoder of the kind needed to digitise raster well logs, the choice between a quantized CPU host and an accelerated GPU host is not a single answer but a frontier whose crossover moves with input width, and that the air-gapped reality of field operations pins many deployments to the CPU end of it. The encoder decoder we use as the worked example is our own VeerNet system.

Why We Skipped Non-Maximum Suppression to Keep the Pipeline End-to-End

A reviewer asked us to render attention maps back onto the borehole log, and the same architecture fact that made that impossible is the one that makes our fracture detector genuinely end-to-end. We never run non-maximum suppression. Overlapping predictions get resolved by bipartite Hungarian matching inside the network, not by a post-processing pass bolted on after. Here is why that one design choice does double duty, and why self-attention on a compressed [Batch, 256, 50, 23] feature map cannot map back to an 800 x 360 image.

From a 1999 Patent to Transformers: 24 Years of Trying to Automate Fracture Picking

The problem statement for automated borehole-image interpretation was written down and patented in 1999, and it has not changed since. Schlumberger's US 5,960,371 already named the same three feature classes we target today (fractures, beddings, elliptical vugs) and read them as sinusoids in the unrolled image, descending straight from Hough's 1962 patent. What changed in a quarter century is not the target but the method that finally hit field-usable accuracy: a well-scale supervised transformer, in 2023.

How to Read a Benchmark Without Being Fooled by It

A field note on benchmark literacy, grounded in one of our own runs. A single headline segmentation score can read as excellent or as poor depending only on how you slice it, and the slice is a choice the reader makes, not a property of the model. This post walks three tests a score has to survive before it means anything: subtract the base rate, so a class that owns the pixels does not score high for free; split the number by class, because the mean drowns the classes you built the model for; and check that held-out really means unseen rather than merely later. We use our multiclass Dice-loss curve-segmentation numbers as the worked example, where a background IoU of 0.94 and F1 of 0.97 sit next to curve masks at 0.26 and 0.21 IoU, and where recall near 0.97 hides precision collapsing on the foreground. The point is not that the model is bad; it is that the aggregate was never the thing to trust.

Gas-to-Grid-to-GPU: Oil & Gas as AI Infrastructure

How natural gas producers can pivot from fuel supplier to full-stack AI infrastructure operator — owning the power, the data center, and the revenue stream.

Depth Registration Is Where Subsurface AI Quietly Breaks

The least glamorous failure surface in a subsurface machine-learning pipeline is not the model, it is the depth reference. An image log, an interpreter's Excel pick sheet, and a derived-property file each carry their own idea of where a feature sits, and a silent centimetre-scale offset between any two of them does not blur a label, it displaces it wholesale. This is a data-plumbing note on the depth mismatch that stalled our labeling for weeks, the reconciliation discipline that unstuck it, and why the 1-pixel = 3-cm raster floor is the precondition before any reported accuracy number means anything.

GDPR Rails for O&G AI: Signing a Data-Processing Agreement Before the First Model

A compliance note from the actual paperwork. Before we trained a single model on a mid-sized Middle East carbonate operator's confidential image logs, we signed an EU-servers-only data-processing agreement that fixed the processing scope, the sub-processor rules, and the cross-border limits up front. The agreement predates the first supervised model by about two years. This piece argues that fixing those rails early, rather than retrofitting them after the data has already moved, is what let an EU vendor lawfully handle a Gulf operator's data, and it walks through which clauses matter most once the processing is AI-specific.

The Apparent-Dip Blocker: How One Missing Column Stalled Supervised Learning for Months

Supervised training for a carbonate fracture-detection model could not start until one derived column arrived: apparent dip and azimuth. In Phase 1, all five wells the operator sent were rejected because that column was absent, and the schedule sat idle for months while everyone waited on data nobody could compute for them. This is the project-management version of a labelling story: how a single missing dependency landed on the critical path, why no model change could unblock it, and how a data-timeliness clause in the service agreement decided who paid for the wait.

From Interpreted Picks to Synthetic Sinusoids: How We Manufactured Training Labels From an Excel Sheet

Before a transformer could detect anything, it needed labels, and the labels did not exist as pixels. They lived in an Excel sheet the operator's geologists had already filled in: one row per pick, four columns, measured depth and dip and azimuth and a type flag. This is the plumbing story of how that sheet became supervised ground truth. Each row was regenerated into a full sinusoid with the notebook's own line, sine_curve = tan(Dip)*sin(theta + Azimuth) swept over 0 to 360 degrees, then stacked at its measured depth to build a synthetic labelled section. One well gave us 1501 bedding picks over 2227.9 to 2890.3 m this way. It is the least glamorous step in the whole pipeline and the one that made end-to-end detection possible at all.

An Artifact Field Guide for Subsurface AI Teams: Woodgrain, Key-Seats, and Dead Pads Before You Train

Borehole-image artifacts sort into four categories a 1999 taxonomy nailed down, and the two that matter most to a model are the ones you cannot see. Faulty inclinometry and a wrong hole diameter leave the picture looking like clean geology while the dip and azimuth labels underneath are already wrong. A field guide to naming artifacts before you train, and the pre-training QC checklist that came out of excluding two wells for it.

Lessons From Shipping a Vision Pipeline in Sixteen Weeks

A delivery-economics note on the two ways to price a vision-pipeline build, written from the one time we ran the fast one. The engagement offered two contracted tracks for the same subsurface digitisation system: a standard 32-week track at 4 FTE for 100000 EUR, and an accelerated 16-week track at 6 FTE for 180000 EUR. It is tempting to read the accelerated track as the same plan run faster by a bigger team. The arithmetic says otherwise. The accelerated week costs 3.6 times the standard week, and the acceleration premium is 80000 EUR, but the accelerated track commits 96 FTE-weeks of labor against the standard track's 128. You pay more for less total work, which is only coherent if the plan itself got smaller: some of the four project blocks carried at less depth. This is a piece about what an accelerated schedule actually buys, which is a compressed team on a trimmed scope, not free speed, and about the delivery decisions that follow once you accept that framing rather than fight it.

Promptable Segmentation Models and Their Limits on Scientific Line Images

A reading of the promptable segmentation model family, from the Segment Anything line to its efficient and high-quality descendants, against a task it was never trained for: recovering one-pixel-wide curves from a scanned well-log. The promptable foundation models are trained to snap onto object-like regions in natural photographs, and that training objective is exactly why they lose thin ink. We set that lineage next to a purpose-built, region-trained curve segmenter from our own raster-log work, where the background class is nearly solved at an intersection over union of 0.94 while the two one-pixel curves sit at 0.26 and 0.21 with a peak intersection over union across the run of 0.51. The point is not that the region-trained model is good in absolute terms; it is that it recovers real foreground on an input where a prompt-driven blob model recovers almost none, because foreground is under two percent of the pixels of a single-channel grayscale image three-to-twelve-thousand pixels wide. Promptability is a genuine advance in interface, and it is not the same thing as usefulness on scientific line data.

The Quiet Rise of In-House AI Teams at Oil and Gas Operators

Operators used to treat subsurface AI as something you licensed, one seat at a time, from a vendor whose model you never got to open. That is changing. A quieter pattern is taking hold, where a Texas onshore operator stands up a small in-house capability instead, and owns both the model and the number on the invoice. This is a build-versus-buy note from the operator's side of the table: what a fixed-price, phased build actually costs, how an accelerated track trades money for time against a standard one, and where the per-seat licence stops being the cheaper option. The technical story of VeerNet lives elsewhere; this is the story of the decision to build it in the first place, told through the two numbers that decide it, the outlay and the seat count.

Well-to-Well at Field Scale: Bootstrapping Correlation with FORCE-2020 Open Data

How a subsurface-AI team de-risked a field-scale well-to-well correlation feature by bootstrapping the method on 118 public Norwegian-Sea wells before any operator data was clean — then shipped fracture and bedding-density logs plus 2D/3D kriging across a target carbonate formation for a Middle East operator we partnered with.

Borehole Image Logs Are a Natural Masked-Autoencoder Problem

A high-resolution borehole image log covers only about 80% of the well wall, so every unrolled image arrives pre-masked by inter-pad blank strips, at roughly the same fraction masked-autoencoder pretraining imposes on purpose. We read the MAE paper within weeks of its December 2021 release, in the same stretch we were running a NaN-imputation bake-off on those blank strips, and the resemblance was hard to miss: an image log is a masked image before any model touches it. This piece argues that self-supervised reconstruction on unlabelled well-kilometres is the setup the data already hands you, not the label-hungry supervised default the field reaches for first.

Eleven Classes in the Field, Three in the Model: Designing a Label Schema From an Operator's Taxonomy

The vendor interpretation report we set out to replace distinguished eleven dip categories, each with its own colour-coded tadpole. We trained on four. This is the case for collapsing an operator's mandated nomenclature: on fourteen wells a per-class census shows one continuous conductive fracture and three continuous resistive fractures in a whole well, counts that cannot support a class of their own. We fold conductive and resistive fractures across the continuity split, pool the examples, and recover the fine distinctions after the fact from image intensity and trace completeness. Inheriting the taxonomy wholesale would have starved the model before it saw a second well.

Geoscience Language Models: A Survey of LLMs for Reports, Logs, and Well Metadata

A survey of the emerging family of geoscience language models, read for one practical question: where in the subsurface stack does a language model actually add value, and where does it hit a wall? We separate the two kinds of signal a well produces. There is text, the report prose, the log header block, and the tabular well metadata (the 22 electrical-measurement feature columns across the 118 Norwegian-Sea wells in the public FORCE tutorial data), which a language model can read, summarise, and query. And there is geometry, the shape of a curve on a scanned log, which our raster digitiser recovers at a best single-curve R-squared of 0.9891 and a lowest mean absolute error of 0.0132, and which no language model reads because it is not text about a well but a line on an image of one. The central finding is that a geoscience LLM complements rather than replaces the vision digitiser: it addresses the words around a well, the vision model addresses the trace itself, and the honest ceiling for either sits under the reported 20 percent drilling cost-savings figure for upstream machine learning. This is a survey of the public field; the digitiser metrics are ours and are used as a worked contrast, not a new benchmark.

The Marginal Cost of the Next Digitised Log Is a Serving Number, Not a Training One

A serving-economics note on what it actually costs to digitise one more scanned paper well log once the model is already trained. The training bill for VeerNet, the encoder-decoder EarthScan uses to lift curves off raster logs, is a fixed one-off: 50 epochs cost 110 minutes on the 2,000-log binary set and 550 minutes on the 15,000-log multiclass set, paid once. What matters for the archive is the marginal cost of the next log, and that number is a single division: the hourly GPU rent divided by the logs the served model clears that hour. Because one trained model serves every scan width through 32-pixel alignment, throughput is a serving property, not a training cost, and the per-log number collapses as throughput rises. This piece derives that unit cost honestly, separates the sourced tier prices from the illustrative serving assumptions, and refuses to dress an engineering figure up as a price.

The Dated Innovation Log as an Audit Artifact: Writing the Verdict Before You Know the Ending

The most defensible document from a year of subsurface research was not the model that shipped. It was a dated log that recorded each approach as it was tried, each verdict written the week it was reached, and one unedited placeholder that nobody bothered to clean up. This is a piece about the log as a governance artifact: what it must capture to survive a ministry-board or peer-review audit, why the verdict written in the moment beats the tidy story assembled afterward, and how an accidental placeholder became the strongest evidence the record was contemporaneous.

DVC + Weights & Biases: Making a Subsurface Model Reproducible

A field-tested account of how versioned data and experiment tracking turned a research-grade borehole-geology model into a reproducible one — and why, without that lineage, a 14-well ablation table is just a set of numbers nobody can defend.

Thin-Structure Segmentation Beyond Well Logs

A field-education note on why the hard part of digitising well-log curves was never the wells. The genuinely difficult thing was learning to find a one-pixel-wide bright line inside a raster that is almost entirely background, and that difficulty is not specific to subsurface data. It is the defining shape of a whole class of line-art problems: cartographic contours, engineering drawings, schematic diagrams, chart trend lines. Each of them presents a model with the same lopsided ratio, a tiny sliver of foreground pixels against an overwhelming empty field, and each of them inherits the same set of tools we assembled for VeerNet, EarthScan's raster-log digitiser. This is a primer on that transfer: what carries across domains, what does not, and why the loss functions and class-weighting tricks that worked on our curves are the portable part. On our own logs the two curves cover under 2 percent of the pixels and roughly 97 percent is background, and on that shape the model reached a peak curve R-squared of 0.9891 under Tversky loss with a per-curve depth error of 0.0277 and 0.1241 under that same loss. Those numbers are ours; the playbook is not.

Self-Supervised and Foundation-Model Pretraining for Document Segmentation

A survey of one narrow slice of self-supervised transfer: the part that matters when the downstream task is dense prediction on documents rather than classification on photographs. The organising question is not which pretext to run, which we surveyed separately, but whether the representation a pretext learns actually transfers into per-pixel mask accuracy, and whether the foundation-model framing that reshaped document understanding buys anything for document segmentation specifically. We credit the transferability studies that first measured how far a learned feature carries, the document-image self-supervised models that made pretraining a default for layout and OCR, and the segmentation-foundation line that promises a generic mask model, then read all three against a real, small dense-prediction baseline: our raster well-log digitiser, CurveNet, a compact encoder-decoder with a 128-dimensional bottleneck, five encoder residual blocks, five decoder stages, and two transformer attention layers, taking a single grayscale channel and fine-tuned on 2,000 binary and 15,000 multiclass labelled instances. The finding is that transfer is real but is a downstream-accuracy claim that has to be measured on the mask, not assumed from a good reconstruction loss, and that the foundation-model promise is strongest exactly where our regime is weakest: on the natural-image scale these models are pretrained at.

What an Accelerator Cohort Actually Changes About a Startup

The cheque is the least interesting thing an accelerator gives you. A note on the counterfactual we actually care about: subtract the money, and what does six months in a cohort change about a startup that the same money outside a cohort would not? The honest answer from our own program is that the change is the network the cohort points into and the cadence that delivers it. On paper that reach is a set of counts: 1,500-plus startups supported, a 120-plus member program team, 50-plus countries. Those numbers are latent until a delivery machinery converts them into something a founder can use: 100-plus hours of curriculum, up to 12 hours of mentorship, six two-hour monthly masterminds across a six-month program. This piece separates the two - the reach and the cadence that lands it - and argues that the accelerator's real product is the second, because the reach is the same whether or not you show up, and the whole lift lives in showing up. It is deliberately not a piece about readiness gating or about the equity we traded for engineering; it is about the peer and network counterfactual that the money alone does not buy.

Averaging the Endpoints: Weight Soups and SWA for Small-Data Dense Prediction

A survey separating two ideas the literature often blurs: averaging in weight space (stochastic weight averaging, the exponential moving average of weights, and model soups) and averaging in prediction space (deep ensembles). We trace weight averaging to its stochastic-approximation roots, credit the period-correct work that turned it into a practical regulariser for a single run, and read the synthesis against a real small-data dense-prediction baseline from our raster well-log digitiser, VeerNet, where a multiclass segmentation hits a background-mask intersection over union of 0.94 and a best single-curve goodness-of-fit of R-squared 0.9891 after fifty epochs at batch size one and roughly 550 minutes of wall clock for the fifteen-thousand-log set. The central finding is that for a memory-bound run on one GPU, averaging the weights of late checkpoints recovers much of an ensemble's stability and flat-minimum benefit at a single network's inference cost, which is exactly the trade a one-GPU dense-prediction project should want. This is a survey of the published field and credits the prior art that defined it; the engagement numbers are ours and are used as a worked example, not as a new benchmark.

The Economics of Automated Interpretation: Reviewing Published Cost and Throughput Studies

An inference-economics literature review of the speedup and cost-saving figures that upstream-AI papers and vendor decks put in their headlines. We collect the most-cited published numbers, namely a 1,000,000x DNN-versus-manual geological-mapping factor, a 200-to-2000x reservoir-simulator proxy speedup, a 100x production-forecasting speedup, and a 20% drilling cost saving, trace each to what it actually measured, and read them against the units economics that decides whether automation pays. The recurring problem is not that the numbers are fabricated but that they are kernel measurements quoted as job-level outcomes, and that a throughput factor and a cost ratio are silently treated as the same currency. We offer a short discipline for deflating any such headline to an effective end-to-end figure before it enters a business case.

Read the Header, Not the Curves: Why OCR Still Earns Its Keep

A method primer that separates the two vision problems hiding on one scanned well log. The plotted curves are a segmentation problem that needs a learned pixel model. The printed header block (track labels, depth scale, units, column names) is a recognition problem where cheap classical OCR beats a segmenter on cost and reliability. Treating them as one problem is the mistake; routing each to the right tool is the win.

The Tilt of a Real Scan: Perspective Augmentation for Field Photographs

A synthetic well log is rendered perfectly square: every depth row is axis aligned because the renderer drew it that way. A phone photo of the same log on paper is not. The page is never flat to the lens, so the ruled grid arrives keystoned, and a model trained only on square inputs meets a geometry it has never seen. This is a sim-to-real primer on one specific augmentation gap and the cheapest transform that bridges it: perspective warp, applied to the synthetic canvas before the network ever sees a field scan.

Serving a Model Inside a Closed Oil-and-Gas Network

Production subsurface AI is not a cloud-inference problem — it is an on-prem serving problem where the network's air gap is a hard requirement, not a deployment preference. This is how a fracture-detection model went from a notebook on a GPU server to a per-well inference service inside a mid-sized Middle East carbonate operator's closed corporate network: a Streamlit app containerized with Docker, exposed on port 8501, reachable only over an internal LAN API into the operator's earth-analytics platform, with zero internet egress.

Reading a Pitch Deck Like an Engineer

A founder reads a pitch deck as a story that builds to an ask. An engineer reads it as a stack of claims, each waiting to be stress-tested against the evidence printed next to it. This is a note on the second habit applied to our own deck: how to decode a market slide, a pricing slide, and a traction slide into three parts each, the claim the slide wants believed, the evidence actually on it, and the assumption the claim quietly rests on. The technical move is to reconstruct the unit-economics bridge the slide left implicit. A 134 billion dollar market that resolves to 180 million dollars of revenue at 1,200 dollars a seat is really a claim about selling roughly 150,000 seats, and a 6 million dollar first year is a claim about roughly 5,000 of them against a burn the seed-and-runway pair fixes. Say the implied number out loud and the slide either survives its own arithmetic or it does not. This is deliberately not a market-sizing walkthrough or an account of readiness gates; it is the reading procedure itself.

Federated and Privacy-Preserving Learning Across Operators: A Subsurface Survey

A survey of federated and privacy-preserving learning read against a problem the subsurface has always had: the data that would train the best model is split across operators who compete and will not share it. We separate the two things the field keeps blurring, moving raw data versus moving model updates, and trace the federated-averaging line, secure aggregation, and differential privacy to the period-correct work that defined them. We read the synthesis against a real single-operator baseline from our raster well-log work: an archive of 136,771 TIF and 7,781 LAS scans, dense-prediction models trained batch-of-one under a hard GPU-memory ceiling on rented cards at 750 and 1,800 EUR per month, and a shared target that peaks at R-squared 0.9891. The central finding is that federated learning changes what an operator is optimising over: instead of the archive it owns, it trains against the union of every participant's archive while every raw scan stays resident behind its own firewall, and for small, memory-bound, single-GPU projects that union is the cheapest way to enlarge the effective corpus without a data-sharing agreement no competitor will sign. This is a survey of the published field; the engagement numbers are ours and are used as a worked baseline, not a new benchmark.

Digitisation as a First Step Toward Subsurface Digital Twins

A digital twin of the subsurface is a fashionable phrase, and most of the pictures drawn under it start at the top: a living model that updates as new data arrives, wired to sensors and simulators. This note argues the opposite direction. A twin is the top rung of a feedstock ladder, and the rung nobody photographs is the one holding it up: machine-readable curves. Underneath depth-aligned features, calibrated physics, and a live model sits a layer of vectorised well-log curves, and every rung above it is gated by how faithfully that base layer was recovered. We built that base layer at scale on a Texas onshore archive of 136,771 raster images and 7,781 LAS files, and we can put a number on the recovery fidelity: peak R-squared 0.9891, lowest MAE 0.0132. This is not a build guide for a twin. It is an argument about where a twin actually starts, and why the least glamorous rung is the load-bearing one.

The Right Way to Report a Segmentation Ablation

A loss-function ablation is a controlled comparison, and the reporting is half the experiment. When we swapped the loss on VeerNet's curve-segmentation head across five candidates, the honest way to write it up was to hold the training budget fixed at fifty epochs and an 80/20 split, then put every metric next to every loss so a reader could see for themselves which cell each one wins. The result is not a single winner. Tversky posts the lowest curve1 error, 0.0277 MAE against Dice at 0.0367 and Focal at 0.0405, and the lowest curve1 MSE, 0.0021 against Dice at 0.0091, but the only run with an archived mask IoU and F1 is the Dice run at 0.26 and 0.37, so no loss leads on curve error and mask quality at once. This note is about the discipline that makes that finding trustworthy: the same budget for every arm, every metric on the page, and an explicit blank where the number was never logged. It is not a reprise of the VeerNet result. It is the reporting standard that lets the result mean anything.

Productizing a Paper: Turning a Borehole Transformer Into AutoFrac, AutoVug, and Well-to-Well

A peer-reviewed borehole transformer with a 65% F1 abstract is not a product. The gap from that number to AutoFrac, AutoVug, and a well-to-well tool running on-prem — 5x faster picking, +60% productivity, 95% target precision — is packaging, serving, and CI/CD, not a new model architecture.

Weak and Self-Supervision: Getting Labels Without an Army of Annotators

A segmenter needs labelled examples, and the honest count of examples a human drew for our raster well-log work is 2,000. The rest of the training supply, 15,000 synthetic multiclass instances and 20,000 synthetic 2-curve logs, was manufactured with the mask handed back for free, and the encoder got a no-label warm start from reconstruction pretraining on top. This note is about why that stack is the rational answer to a 136,771-file raster archive that is economically impossible to annotate by hand, and about reading label sources as an engineering supply chain ranked by yield rather than a single annotation budget to be spent. It credits the public lineage of weak and self-supervision, then sets the two label-manufacturing routes we actually leaned on against the counterfactual bill they let us skip.

Class Imbalance Beyond Loss Functions: Sampling and Tiling

Reweighting the loss is only half the fix for a 97-percent-background segmentation problem. We walk the data-side half: how stratified sampling and tile cropping change what the optimiser sees per step, so the loss starts from a far gentler imbalance than the raw frame. We frame the field's two sampling families, ground them in our own VeerNet raster-log pipeline where the do-nothing baseline peaked at an IoU of 0.51, and show with an interactive board how tile size and oversampling move the foreground fraction before a single class weight is applied.

Sharp Wells and Flat Basins: Loss-Landscape Geometry in Thin-Curve Segmentation

A survey-plus-evidence reading of why our five segmentation losses generalised so differently on a thin-curve raster-log task, organised around the public sharpness and flat-minima literature. We credit the line of work that argues wide, flat basins in the loss surface tend to generalise better than sharp, narrow minima, and the careful rebuttals that complicate that picture, then read the synthesis against our own measured sweep where the do-nothing baseline peaked at a validation intersection over union of 0.51, a Dice loss scored per-class IoU of 0.94, 0.26, and 0.21 on background and the two curves, and the best Tversky configuration reached an R-squared of 0.9891 on a recovered curve over 15000 multiclass instances trained for 50 epochs. An interactive traverse lets the reader walk a one-dimensional slice through the trained minimum and read the held-out IoU off the basin width.

The Quiet Power of a Good Data Contract Between ML and Frontend

Most integration bugs in an ML product do not live in the model or in the dashboard. They live in the schema between them, the agreed shape of the payload the model emits and the frontend reads. This piece argues for designing that mask-to-CSV contract first, as a versioned artefact in its own right, so the dashboard team can build against a frozen interface weeks before the final model exists. We credit the contract-testing and schema-validation literature period-correctly, then ground it in our own raster-log digitisation work: a payload of 300 interpolated depth points per curve, a 3-class mask convention, and a per-curve mean absolute error of 0.11 and 0.12 that the contract has to declare honestly or render fake precision.

The Long Tail of OCR: Reading Headers off Scanned Logs

Reading the printed header off a scanned well log is the part of digitisation everyone calls easy, and for most of the page they are right. The trouble is that the same job is also where a surprising amount of the engineering quietly goes, because the headers do not fail on average. They fail in a long tail of rare malformed cases: faded carbon copies, sheets scanned off-square, vendor abbreviations that collide, stamps printed over the title block. This is a tour of that tail, and of why it is a separate concern from the much-debated question of whether to OCR the header at all.

Competing With Enverus and IHS Without Their Data Moat

A product-strategy note on the trap of picking a fight you cannot win. The dominant subsurface-data companies, Enverus and IHS among them, own decades of licensed well and production data, and a digitisation startup that tries to out-collect them loses on day one. We took the opposite axis. Instead of building a rival corpus, we turn a customer's own trapped archive, the scanned raster logs already sitting on their drives, into usable curves at a marginal cost set by a rented GPU rather than a data licence. This piece lays out why that positioning holds, what the arithmetic looked like, and where it is fragile.

Synthetic Data for Chart and Plot Understanding: Datasets, Generators, and Gaps

The chart-extraction field is trained almost entirely on synthetic figures, and the reason is mechanical: a plotting library that renders a chart already holds the exact numbers behind it, so it can emit a perfect label in the same call that draws the pixels. This survey looks not at the extraction methods that consume those corpora, which a companion survey already maps, but at the generators that produce them and at where their emitted labels stop matching a real scanned figure. We read the synthetic splits behind ChartOCR, LineEX, and the ICPR 2020 chart competition as programmatic engines, and we set our own render-and-emit-mask generator beside them as a worked parallel: 15,000 synthetic curves at pixel-perfect mask fidelity, spanning 3,200 to 12,800 pixels wide and 480 to 640 tall. The finding is a fidelity cliff. Every one of these engines is exact on geometry, because geometry is the one thing a renderer cannot get wrong about its own output, and every one leaks on style, occlusion, and annotation realism, because those are the properties a renderer never has to reconcile against a scanner. The label fidelity a synthetic corpus advertises is therefore not one number but a profile, high on the left and thinning to the right, and knowing that profile is the difference between a generator that transfers and one that quietly teaches a model the wrong invariances.

The Inventory App: Where Digitisation Meets Asset Management

A product note on the part of a log-digitisation system that gets the least attention and does the most work: the inventory. Extracting a curve off a scanned raster produces a machine-readable file, but a file that is not registered anywhere is not an asset, it is a result that will be re-extracted next quarter by someone who could not find it. The inventory app is the layer that turns a one-off extraction into a durable, searchable subsurface-data holding, and it is where digitisation stops being a script and starts being asset management. Grounded in an engagement whose source archive was 136,771 TIF scans and 7,781 LAS files, this walks the four-step scan-to-CSV loop, shows why registration is the step that creates value, and treats the per-seat access model as a consequence of the inventory rather than the digitiser.

From One Well and 32 Sinusoids to a Production Fracture Detector

A Detection Transformer that picks fractures on borehole image logs is the visible 15% of the work. The other 85% is data engineering. This is the build log of how a fracture detector grew from a single well with 32 hand-picked sinusoids and 236 patches to a 75,000-patch training corpus — a 132x expansion driven not by a new architecture but by augmentation and overlapping-window sampling. The lesson for any applied-AI team: the dataset, not the paper, was the product.

Physics or Data: The Long Debate in Subsurface Modeling, Explained

The subsurface community has spent years arguing physics-first simulators against pure data-driven nets as if one had to win. Read as a spectrum instead of a fight, the families stop competing and start slotting into the regime each is good at: a first-principles solver where the physics is known and trusted, a data-driven net where it is not, and, carrying most of the practical speed, a surrogate net that stands in for an expensive simulator. This is a model-family explainer, not a reprise of our VeerNet architecture paper. We ground it in the acceleration numbers that actually separate the families, from a reservoir surrogate running 200x to 2000x over a conventional simulator, through a 100x-plus production-forecast booster, to a geological mapping net claiming up to a millionfold over hand work, and a pure data-driven digitiser that reaches an R-squared of 0.9891 with no physics prior at all.

Building a Reusable Synthetic-Data Generator for Chart Digitisation

We built a procedural generator to manufacture training data for a raster well-log digitiser, because no labelled corpus of scanned logs existed to learn from. The surprise was what came out the other side. Once we stopped hard-coding petroleum specifics and started passing axis ranges, gridline spacing, curve count and image dimensions as parameters, the same engine could draw any ruled line chart. This is a field-level look at why chart digitisation is one problem wearing many domain costumes, where the synthetic-data and chart-extraction literature already pointed this way, and how treating geometry as a parameter turned a one-off log generator into a reusable engine.

Building the Curve Generator's Realism Knobs

A synthetic-data generator is rarely one switch. Ours is a small bank of realism knobs (page skew, ink bleed, grid jitter, paper noise, stroke variance) and the question that matters is not whether the generator helps but which knob does. This post surveys how the field learned to attribute a model's behaviour to individual factors rather than to a pipeline as a whole, from ablation studies to Shapley-style credit assignment, and then turns that lens inward on our own curve generator. Built to render synthetic raster logs across a 3,200 to 12,800 pixel width range and a 480 to 640 pixel height range at a constant two curves per log, the v2 generator produced the 15,000-curve training set we train VeerNet on. We attribute the downstream validation lift knob by knob, and the ranking, not the total, is the finding.

Interpolating to 300 Depth Points for Apples-to-Apples Validation

You cannot compare a predicted curve to ground truth at mismatched sampling. The recovered curve and the LAS reference land on different native depth grids, so subtracting them sample for sample is meaningless. Resampling both to a common 300-point depth grid is the unglamorous step that makes MAE and MSE actually mean something, and it is what lets the digitised curves report an honest CSV MAE of 0.11 and 0.12 under Dice loss.

Are the Model's Confidences Honest? A Per-Curve Calibration Study

Overlap metrics tell you whether a segmentation mask is in the right place; they say nothing about whether the probability attached to each pixel can be trusted. This study asks a different question of a three-class raster-log segmenter: are its per-pixel confidences calibrated, class by class? We survey the calibration literature that the field has built since 2005, then read it against our own Dice baseline, where the easy background class is essentially solved while the two thin curve classes sit far below ceiling. The pattern is the one the literature predicts for heavy imbalance: a confident, slightly over-confident majority class and two minority classes whose stated certainty their pixels do not earn. VeerNet is our raster-log digitiser; the calibration question is about whether to believe what it reports.

From a Customer's Scanned PDF to a LAS File They Trust: The Onboarding Funnel

When an operator hands us a folder of scanned well logs, none of them are LAS files yet, and not all of them will become one. The honest way to describe a digitisation deployment is not as a single accuracy number but as a funnel: of the raster scans an operator uploads, what fraction clears header track detection, then pixel segmentation, then vectorisation, and finally a validation bar strict enough that the customer trusts the LAS file that comes out. This piece walks that four-step flow the way an interpreter actually clicks it, names where scans drop off, and is explicit that the last step is a dial, not a constant: a stricter validation bar delivers fewer files but every one of them clears a higher fit, toward the peak R-squared of 0.9891 and the lowest mean absolute error of 0.0132 we measured. The instrument fans the upload batch out across the four stages so you can drag that bar and watch delivered volume trade against quality, anchored to the engagement's own evidence: a four-step dashboard, eight real scans validated end to end, three letters of intent from pilot customers, and a reference archive of 7,781 LAS files against 136,771 scanned TIF images.

Closing the Sim-to-Real Gap with Targeted Degradation Models

Generic augmentation is not enough. A segmentation network trained on 15,000 clean synthetic well-log curves reads its own held-out renders at R-squared 0.9891, but that is the clean-synthetic ceiling, not the real-scan score. This note sets our VeerNet sim-to-real result beside the public literature on degradation modelling, domain randomisation and robustness, and argues that the gap onto real Texas RRC field scans is closed one targeted degradation at a time: perspective tilt, paper noise, ink bleed and skew, each modelled the way a real scan actually carries it. The literature said which corruptions matter; our numbers say what each one costs.

Sim-to-Real Failure Modes, and How to Tell Which One You Have

A synthetic-trained segmenter does not fail on a real scan in one way; it fails in four, and the fixes do not interchange. We read VeerNet's own held-out numbers as a diagnostic table rather than a scoreboard: a clean-synthetic peak of R-squared 0.9891 next to multiclass curve IoU of 0.26 and 0.21 is not a single regression but a fingerprint that names the failure. This note sets a taxonomy of sim-to-real failure modes beside the public literature on covariate shift, domain adaptation, corruption robustness and out-of-distribution detection, and argues for triage first: covariate shift, class confusion, localisation drift and out-of-support artefact each leave a distinct signature in recall, IoU and R-squared, and each demands a different intervention. Treat the wrong one and you spend a render budget on a problem you do not have.

Soft Cross-Entropy and Label Smoothing on Fuzzy Curve Edges

Where a scanned curve's edge is genuinely ambiguous, a hard 0/1 label tells the network a lie: it claims the boundary pixels are certain when they are not. Soft cross-entropy and label smoothing treat that boundary as the uncertain band it actually is, and the survey literature explains why that is sometimes the honest model and sometimes a quiet harm. It was one of the five losses we measured for VeerNet, our raster-log digitiser.

Topology-Aware Losses and Connectivity Metrics for Thin-Structure Segmentation

A literature survey of why pixel-overlap objectives reward a fragmented thin curve almost as much as a connected one, and of the connectivity-preserving losses and topology-based metrics the field has built to close the gap that intersection over union is blind to. We trace the line from skeleton-aware and centreline-Dice losses through persistent-homology and Betti-matching objectives, credit the prior art that defined each, and read the synthesis against a real raster-log curve task whose peak intersection over union of 0.51 and peak F1 of 0.55 sit comfortably high while the underlying digitised curve can still arrive in pieces. The survey's argument is that for one-pixel structures the metric and the objective have to be changed together: an overlap score cannot see a broken curve, and a loss that optimises only overlap will not learn to connect one.

Uncertainty Quantification and Confidence Thresholding in Petrophysical Interpretation

A segmentation model that digitises a raster well log emits a softmax score for every pixel, but a score is not a decision. This survey reads how the literature converts that score into an operating rule: where to set a confidence cutoff so the model auto-accepts the depths it is sure about and escalates the doubtful ones to a human. We trace the reject option from its decision-theoretic origin through the modern selective-prediction and out-of-distribution detection work, separate the two distinct moves a threshold makes (it must be a trustworthy ordering of pixels, and it must sit at a defensible point on the risk-coverage curve), and read the synthesis against our own three-class raster-log baseline. There the easy background class carries a recall of 0.97 and a precision of 0.96 while the two thin curve classes sit far below ceiling at recall 0.37 and 0.32 and precision 0.41 and 0.36, which is precisely the regime where a single global cutoff is the wrong tool and a per-class cutoff is the right one. VeerNet is our raster-log digitiser; the thresholding question is about what to do with the numbers it reports, and the prior art it leans on is credited throughout.

What 136,771 TIFs and 7,781 LAS Files Teach You About Real Data

Scope a real subsurface dataset before you model it and the first thing you learn is that the part you can train on is the small part. The public Texas regulatory archive holds 136,771 scanned raster well logs but only 7,781 machine-readable LAS files, a raster-to-vector gap of roughly 17.6 to 1. We credit the data-centric-AI argument and the public archives that make the contrast visible, then explain why that single ratio, not a modelling preference, is what made a 15,000-curve synthetic corpus mandatory rather than optional for training our raster-log digitiser, VeerNet.

The Long History of Teaching Computers to Find Lines

A computer-vision primer on the one task that never changed and the method that kept changing under it: finding a line in an image. The arc runs from hand-tuned edge operators, through the Hough transform, to filter banks learned from labels, and finally to per-pixel segmentation nets. Each generation kept the same job and traded a set of knobs the engineer used to turn by hand for structure fitted from data. The well-log net EarthScan built to lift curves off scanned paper logs is the latest step on that arc, not a break from it: peak IoU 0.51, peak recall 0.97, peak R-squared 0.9891 out of a 5-stage encoder-decoder with 2 attention layers, trained on 15,000 synthetic instances that stand in for the heuristics an earlier generation would have hand-set. This is a heritage note, deliberately not a product story: what each generation could and could not do, and why the newest one is a continuation rather than a rupture.

Beating Commercial Tools With Open Methods

The way most vendor comparisons get written is brand against brand: a feature grid, a logo wall, and a footnote about enterprise pricing. We think that table is the wrong table. For raster well-log digitisation, the honest comparison is measured accuracy against measured cost, and when we ran it on our own open-method pipeline the numbers held: a peak curve-fit R-squared of 0.9891 and a peak segmentation F1 of 0.55, trained in 10 hours on the 15,000-log multiclass set, on a GPU that rents for 750 or 1,800 EUR a month. Against a per-seat SaaS licence at 1,200 USD per analyst per year, the open pipeline's cost is flat in team size while the licence bill climbs one seat at a time, and the crossover where the licence overtakes the fixed rent is a number you can put on a scoreboard rather than a slogan. This is not the data-moat argument; it is the accuracy-versus-cost argument, and it is the one worth publishing.

Overfit, Then Fixed: The ~25-Item Backlog That Tamed Our First DETR Model

Our first supervised Detection-Transformer for borehole fracture picking overfit hard — it emitted a constant prediction on validation despite a matched class split. No new architecture rescued it. A ~25-item engineering backlog did: data augmentation alone moved classification error from 100% to 2.618%, and padding, patch-height tuning, dropping the >70-sinusoid patches, and frac-only training did the rest. A field note on why the fix for an overfit model so often lives in the data and training loop, not the network.

Equity for Capability: Structuring a Venture-Network Partnership

At the seed stage a startup rarely has the cash to hire a scarce AI research-and-engineering team outright, and even when it does, spending that cash is exactly what shortens the runway the seed was raised to protect. This is a note on the alternative we used: buying the capability with equity instead of cash, and treating the terms of that trade - the stake issued, the term of the agreement, and the confidentiality period - as the actual price of the capability rather than as boilerplate. A 3M USD seed carrying 18 months of runway is the constraint the whole deal is built around. Against it, a 6-FTE accelerated build over 16 weeks or a 4-FTE standard build over 32 weeks, priced at 180,000 and 100,000 EUR, is the capability being acquired, and a 50% fully-diluted stake with a 3-year term and a 5-year confidentiality period is what leaves the cap table in return. The piece walks the reasoning, not the architecture: why cash is the wrong currency here, what a stake actually buys, and where this structure stops being a good idea.

Instance or Semantic: Choosing How to Slice an Image

A practitioner's decision guide for the first fork in any pixel-level vision task: do you want instance segmentation, which finds and separates each object as its own thing, or semantic segmentation, which labels every pixel with a class from a set you fixed in advance. The two are not competing accuracy tricks, they answer different questions, and the question the raster-log problem actually asks is the semantic one. A scanned well log carries two constant, named curves, so the output classes are known before a single pixel is seen: background, curve1, curve2, three in all. When the class set is that small and that fixed, you already know what is in the picture, and per-pixel labelling is the natural fit. This note walks the distinction plainly, shows where each method earns its keep, and grounds the choice on the numbers from our own runs: a three-class model peaking at F1 0.55 and IoU 0.51 against the fragmented alternative of separate binary masks at F1 0.37, 0.26, and 0.55. It complements the VeerNet whitepaper rather than repeating it: this is the primer, not the research comparison.

Self-Supervised and Foundation-Model Approaches for Subsurface Signals: An Assessment

An assessment of self-supervised and foundation-model pretraining aimed at the part of the subsurface stack that is a signal rather than a picture: the well log, a set of one-dimensional, depth-indexed measurement traces. The organising question is narrow and, we argue, decisive. Not which pretext to run in the abstract, and not how these methods behave on documents or on seismic images, but whether the pretext task a self-supervised objective actually optimises fits a log curve, a thing that is sparse, unevenly sampled, and riddled with intervals that were simply never recorded. We read the period-correct (2023-Q4) objective families in two groups, masked reconstruction and contrastive learning, against the structure a real log imposes: two curves in Track 3 (NPHI, RHOB), three in Tracks 1 and 2, and a public pretraining corpus of 118 Norwegian-Sea wells across 22 electrical-measurement columns. The finding is that transfer is uneven and the unevenness is predictable from the pretext, not from the model size: a masked-reconstruction objective that hides random spans of a trace cannot separate an intended mask from a logging hole, so its benefit collapses fastest exactly where real logs are hardest, while contrastive and denoising objectives that key on depth-local structure degrade more gently. This is an assessment of the published field applied to one signal type; the corpus and signal figures are sourced, the fitness ratings are a reasoned illustration and are labelled as such.

A 1,000,000x Speedup Is a Marketing Number Until You Define the Baseline

A read of acceleration claims in AI-for-upstream by their baseline rather than their headline. The same survey that reports a 1,000,000x speedup for deep-learning geological assessment against manual mapping reports only 100x to 2,000x for the tasks that actually resemble what we do, which is lift curves off scanned well logs. Those numbers are not in tension. They are answers to different questions, and the question is the baseline you fixed. This note is a piece of benchmark literacy for anyone buying, selling, or building subsurface ML: how to take a multiplier apart into the thing measured and the thing compared against, why the largest multiple is almost always the one with the weakest baseline, and what an honest acceleration claim looks like once you insist on knowing what it was faster than. It is deliberately not the VeerNet whitepaper; it is the reading discipline you should bring to any headline like VeerNet's.

The ESG Angle: Subsurface Storage Needs Old Logs Too

Digitising decades of scanned well logs used to be justified by oil and gas alone. Carbon storage adds a second, ESG-driven reason to want the same archive as machine-readable curves, because screening a caprock seal or a saline aquifer for a storage site reads exactly the logs that already sit in the regulator's filing cabinets. This is a note on that new demand driver: a single public archive holds 136,771 TIF and 7,781 LAS scans, and a working CO2-storage pipeline downstream, the kind that forecasts project engagement at 90.476% accuracy in the published case, means those dormant scans now have a buyer they did not have before. It is deliberately not a walkthrough of how a storage project manages its stakeholders, and it is not a survey of who owns the archive; it is about why the pull on the archive is new.

MLOps for Geoscientists: Borrowing Practices From Software, Carefully

MLOps arrived in geoscience as a set of borrowed habits from web-scale software teams, and most of those habits are worth having. But a well-log digitisation model is not a recommender trained on a firehose of clicks. It trains on grayscale rasters that range from 3,200 to 12,800 pixels wide, a fifty-epoch pass costs 550 minutes on the 15,000-log multiclass set and 110 minutes on the 2,000-log binary set, and the GPU is rented at 750 to 1,800 EUR a month. This note is a practitioner's sort of the MLOps toolkit into the practices that copy cleanly into that setting and the ones that need re-cutting before they fit. Dataset and checkpoint versioning transfer as-is; reproducible training transfers as-is; the budgeted iteration loop that software teams take for granted is the one a single long run can quietly break. It is deliberately not a re-telling of how we built the model, which lives elsewhere. It is about which parts of the software playbook a geoscience team should adopt, and which parts to adopt with a modification.

Bottleneck versus Basic Residual U-Nets for Curve Extraction

A controlled A/B on residual block design for raster well-log digitisation. We swap the basic two-convolution residual block for the bottleneck three-convolution variant across the five encoder stages and five decoder layers of VeerNet, hold everything else fixed on the same 15,000-log three-class set, and read off per-class IoU and F1. The architecture lineage is the ResNet residual block dropped into a U-Net encoder-decoder; we credit that lineage rather than reinvent it, and ask only whether the heavier block earns its cost on a thin-curve target.

Splitting by Well, Not by Row: Leakage-Safe Evaluation for Petrophysical ML

A validation score is only honest if no information about the validation samples reached the model during training, and on depth-indexed well-log data the most common way to break that rule is the most innocent-looking one: a uniformly random train-validation split. Because measurements logged a few centimetres apart down the same borehole are almost identical, a random split scatters near-duplicate samples across both sides of the boundary, and the model is effectively graded on points it has already seen in all but name. This survey reads the public literature that named and measured this failure, from the canonical taxonomy of leakage in data mining, through the cross-validation strategies developed for spatially and hierarchically structured data, to the recent accounting of how train-test leakage has inflated published results across machine-learning-based science. We then ground that literature in our own raster well-log digitisation work, where the unit that must not be split is the well, and where synthetic-log identity is a second grouping key the split has to respect. The honest protocol is to group by well so that every sample from a borehole stays on one side of the 80/20 split, and we describe why grouped partitioning, not a larger validation set or a different metric, is what makes a petrophysical model's score mean what it claims. The leakage taxonomy, the grouped-cross-validation methods, and the tooling are the field's; the application to well-grouped digitisation evaluation is ours, and VeerNet, the digitiser whose evaluation we are protecting, is ours.

Focal and Lovasz Losses for Direct IoU Optimisation

Two of the five losses we benchmarked for raster well-log digitisation refuse to play the per-pixel game in opposite ways. Focal keeps the cross-entropy form but shrinks the gradient on easy, already-correct pixels so the model spends its attention on the hard ones. Lovasz-Softmax throws out per-pixel scoring entirely and optimises a tractable surrogate of intersection-over-union itself. This piece is about why those two strategies behave so differently from an overlap loss like Dice, and what each one does to the error left on the recovered curve when the foreground is a one-to-three-pixel ink trace and the peak IoU on the set is only 0.51.

Mask to Centreline: The Geometry of Reading a Curve's Position

A segmentation network does not hand you a curve. It hands you a probability band a few pixels wide at every depth row, and the deliverable a petrophysicist actually reads is one horizontal pixel coordinate per row. This piece is about the reduction in between: how a thick predicted mask collapses to a single position per depth, why argmax-of-column with a local centroid refinement is the right operator for a one-to-three-pixel ink trace, and why per-column position resolution, not how much of the mask overlaps the truth, is the thing that decides whether the recovered curve is usable. The sharpest evidence is a number that looks like failure and is not: a peak intersection-over-union of 0.51 on the multiclass set sitting next to a position error of 0.0277 on curve 1.

The PyTorch Lightning Migration That Cleaned Up Our Training Loop

We trained the first version of our raster well-log digitisation model on a hand-rolled training loop, and it worked, which is exactly the problem. A loop that runs is not a loop you can read. This is the engineering-hygiene story of migrating that loop to PyTorch Lightning: what the bespoke code hid, what the refactor made visible, and the one piece we kept by hand because no framework knows how to batch a 12,800-pixel-wide log raster. The run shape never changed. Batch size 1 for the binary segmentation set and 16 for the multiclass set via a custom collate_fn, 50 epochs either way, 110 minutes on the 2,000-instance run and 550 minutes on the 15,000-instance run. The migration was not about speed. It was about being able to see what the loop was doing.

The Quiet Importance of Dataset Curation

When you can generate training data for free, the scarce decision stops being how much to make and becomes which examples to keep. We credit the data-centric and synthetic-data literature, then walk one concrete curation path from a 2,000-instance binary set to a deliberately shaped 15,000-instance multiclass set, where pruning near-identical synthetic logs and fixing the composition mattered more than any further model tweak.

The Log File Said One Thing, Excel Said Another: The Depth Mismatch That Stalled Labeling

Before a single fracture model could train, two files had to agree on where the well was. The geologist's dip picks lived in an Excel sheet that ran from 2050.42 to 3441.27 m; the binary wireline log file only carried pixels to 2899.99 m. Reconciling pick-to-image depth — not architecture, not augmentation — was the prerequisite no model could skip. A field note on the unglamorous data engineering that makes supervised borehole AI possible.

Hamiltonian Monte Carlo for reservoir characterisation

A webinar recap of Dr. Shib Sankar Ganguli's Bayesian-multivariate Hamiltonian Monte Carlo approach for estimating total organic carbon in shale reservoirs — and why uncertainty quantification matters more than point estimates when characterising unconventional plays.

Founder Geography: Building a Team Across Time Zones

The architecture write-ups explain how we lifted curves off scanned well logs. This is the other account, the operational one, about the people who did it and the map they were scattered across. A founding delivery team spread over several time zones is usually filed under risk: handoffs drop, mornings and evenings never line up, and a two-line question waits half a day for an answer. We ran the accelerated engagement with 6 FTE against a standard-track plan of 4, over a 16-week window instead of 32, and the extra two seats were not simply more hands. They were the seats that let the working day wrap most of the way around the clock, so a model left training under one sky was picked up by someone already awake under the next. Dispersion is a liability right up until the bench is deep enough to turn it into a relay, and this note is about where that line sits, why the handoff discipline mattered more than the raw hours, and what the coordination tax does once you spread too thin. It deliberately does not re-tell the VeerNet model internals; it is the schedule seen from the inside.

Garbage In: The Pixel-Range Bug That Got Two Wells Excluded

Two wells shipped with their high-resolution borehole image-log intensities scaled to 0–15 instead of the expected 0–255 — a silent 16× compression that no model would have flagged and every model would have learned the wrong way. Exploratory data analysis caught it before a single training step, the wells were excluded, and the batch dropped from ten usable wells to eight. A field note on why pixel-range QC is non-negotiable for image-log deep learning.

The 92k-Patch Trap: When More Synthetic Data Made the Model Worse

Augmentation has a ceiling. On a borehole-fracture detector built for a mid-sized Middle East carbonate operator we partnered with, ballooning the augmented training set to 92k overlapping patches actively hurt the model — while adding three real wells lifted depth, dip, and azimuth accuracy. A field note on why real distribution beats synthetic volume, and how to tell which one you are short of.

Data Sovereignty in Upstream Oil and Gas: Where National Subsurface Archives Sit

A field survey of where national subsurface data actually lives and what that means for anyone trying to run automated log interpretation over it. The primary record in upstream oil and gas is a raster archive held by a public regulator, not a private cloud bucket: one state regulator alone publishes 136,771 scanned TIF logs and 7,781 LAS files as sovereign, publicly held records. Because those records are governed by data-residency rules that say where the bytes may sit and cross, the interpretation model inherits a serving constraint before a single epoch is trained. We read that constraint against the compute economics of the alternative, cloud serverless GPU rent of 750 to 1800 EUR per month, and against a build-in-jurisdiction delivery footprint of 4 to 6 engineers over 16 to 32 weeks, and we frame the whole question against a $6.7B oil-and-gas-technology serviceable market whose access is gated less by model quality than by where the data is legally allowed to live. The central finding is that regulator-owned raster archives push automated interpretation toward on-premises and in-jurisdiction serving, and that this is a governance fact, not a preference. This complements our VeerNet architecture work, which is about how to read a raster log; this piece is about where you are permitted to read it.

32-Pixel Alignment and Other Quiet Inference Details

A serving-hygiene note on the unglamorous inference-time details that never show up in a demo and always show up in production. VeerNet, the encoder-decoder EarthScan uses to digitise raster well logs, runs five stride-2 encoder stages, so it only accepts an input whose height and width are divisible by 32. Synthetic logs arrive at any size in a wide band, widths 3200 to 12800 pixels and heights 480 to 640 pixels, so almost none of them land on a multiple of 32 and every scan has to be padded up before the forward pass will run. That is one entry in a longer ledger: NaN and sentinel values like -999, NA, and None that must be caught before they poison a normalisation, and an S3 write-back layout that has to match what the downstream reader expects. None of these is a model change and each one silently corrupts output if it is skipped. This is the checklist we keep, argued from the one defect you can compute exactly, with credit to the people who named the failure modes.

Designing for the Geoscientist Who Distrusts the Black Box

A product note on how we got expert users to adopt a curve-segmentation model whose peak IoU was 0.51. The honest answer is not that we hid the weakness. It is that we surfaced it. A geoscientist who has spent a career reading logs will not trust a mask whose precision on the two curves it exists to trace is only about 0.23 and 0.38, and the per-mask numbers from the binary segmentation run say exactly that. What made the tool usable was one operating property of that same run: recall on the curve masks reaches 0.96 and 0.97, so the model's mistakes are mostly false positives a reviewer can veto rather than misses a reviewer has to hunt for. We built the verification affordances, zoom and per-scan override, at exactly the points where the model is weakest, and validated the workflow over 8 real scans through the dashboard. This is the design argument for that decision, distinct from the modelling account in the VeerNet whitepaper: transparency plus override at the weak points is what turns a 0.51-IoU pipeline into a trusted instrument.

The Sinusoid-Count Skew: Why a Long-Tailed Patch-Label Distribution Wrecked Early Training

A long tail in the per-patch label distribution — not the model — stalled early training of our borehole fracture detector. Over 95% of patches carried a similar, modest sinusoid count and a thin ~5% carried far more, and that skew quietly broke the fixed query budget of a Detection Transformer until we diagnosed it as a data problem and fixed it in the data layer.

The Geoscience-to-CSV Pipeline as a Reusable Pattern

The pipeline we built to lift curves off scanned well logs is not really about well logs. Strip the petroleum vocabulary and what remains is a four-stage image-to-tabular flow: a grayscale raster in, a per-pixel classifier that separates each trace from the background, a centreline extraction that thins each mask to a one-pixel line, and a resample that writes the line out as table rows. Every one of those stages is a stock computer-vision operation, and none of them knows or cares that the chart is a well log. This is a primer that reads the flow as a template. We keep the sourced spine (1 input channel, 3 output classes, 300 resampled depth points, peak R-squared 0.9891, mean CSV MAE 0.0277 on curve1 under Tversky loss, built against 136,771 raster TIFs) and argue that the same four stages digitise any ruled line chart. It is deliberately not a re-telling of the VeerNet architecture or its serving economics; it is the abstraction underneath both.

Reading the Burn Rate: What 88k a Month Buys a Research Team

A spend-mix note on one month of a research team's burn, written from the inside of the accelerated subsurface build. The number that shows up on a status slide is a single figure: EUR 88,400 for November 2021. What that figure hides is where it went, and the where is the part that decides whether the month bought durable capability or just runway. The mix is lopsided by design: six accelerated-track people carry the overwhelming share, GPU rent sits at 750 to 1,800 EUR per card per month as a thin slice, and labelling and tooling make up a small but load-bearing remainder. This is not the month-by-month ledger and it is not the 16-week delivery post-mortem; it is a look at the composition inside one month, and the argument that the composition, not the top-line, is what a sponsor should actually read.

Augmentation Is a Design Decision, Not a Default

The learned-policy line of work, AutoAugment and RandAugment, taught the field to stop hand-tuning augmentation and search it instead. That is the right answer for natural-image benchmarks. For a scanned paper well log it is the wrong question. The transform that earns its place is the one that models a corruption your raster actually carries, and on a single grayscale channel colour-jitter does nothing. Our recipe for raster well-log digitisation is one worked example of choosing augmentation against the failure mode you see.

Throughput on One Card: Batch Scheduling Around a GPU That Keeps Going Down

A practitioner's account of finishing a training run on hardware that would not stay up. Building VeerNet, the encoder-decoder EarthScan uses to digitise raster well logs, we trained the multiclass segmenter for 50 epochs over 15,000 synthetic logs in 550 minutes and the binary segmenter for 50 epochs over 2,000 logs in 110 minutes. The logs are variable in size, which collapses the naive batch size to one and makes throughput a scheduling problem the moment the single GPU box starts dropping mid-sprint. This post walks through the three moves that kept the run inside its window: a variable-dimension collate that lifted the multiclass batch from one to sixteen, the deliberate batch of one we kept on the binary set, and checkpoint-resume that turned each crash into a tax rather than a restart. We credit the dataloader and checkpointing machinery to its authors and claim only the scheduling reasoning as ours.

Knowing When to Quit: Early-Stopping Criteria on a Fixed Fifty-Epoch Budget

A practitioner's note on the two settings that decide when a training run stops short of its cap: which validation quantity you monitor, and how much patience you grant it. Capping a curve-segmentation run at fifty epochs only bounds the worst case. The interesting question is when to quit before the cap, because a run that has already found its best held-out checkpoint is spending the rest of its box-time getting slowly worse. On VeerNet, the encoder-decoder EarthScan uses to digitise raster well logs, a fifty-epoch pass costs 550 minutes on the 15,000-log multiclass set and 110 minutes on the 2,000-log binary set, so every epoch the criterion lets us skip is real GPU box-time back. This is a survey of how the field sets the monitored metric and the patience window, with credit to the people who formalised it, applied to one concrete pair of runs. It is deliberately not a reprise of reading optimiser loss curves; the criterion is a separate dial.

Pricing a Vertical Tool at 1,200 Dollars a Seat

Most pricing essays argue value capture from the bottom up: measure what a feature saves a user and charge a slice of it. This is the opposite walk. We take one real headline number, a 1,200 dollar per-seat annual price for a vertical well-log tool, and show it was reverse-engineered from the top down, from a market size and a revenue target back to a single price. The pricing literature, from van Westendorp to value-based monetisation, mostly tells you how to find willingness to pay. This is a field note on what happens when the price has to satisfy an arithmetic that was fixed before any customer was asked.

Weak Supervision at Scale: Programmatic Labeling Since Snorkel

A survey of how programmatic and weak supervision matured after Snorkel, read as a single arc from data programming through labeling-function abstractions, label-model aggregation, automatic function synthesis, and the benchmarks that finally let the field compare itself. We credit that public lineage in full, then ask the question that decides whether any of it helps us: where do labeling functions sit when there is no ground truth to write functions against. Our raster well-log digitisation regime is the test case, where the hand-labelled floor is a 2,000-instance binary segmentation set and the route that actually produced training data was procedural synthesis, 20,000 generated logs and a 15,000-curve final set. The short finding is that weak supervision and synthesis are not rivals but two answers to two different shapes of label scarcity, and our shape is the one synthesis was built for.

Voting Models: Ensembling Segmenters for Cheaper, Steadier Labels

A practitioner's primer on the oldest trick in the book applied to thin-curve segmentation: train several models, run them all on the same scan, and keep a pixel when enough of them vote for it. We survey how the field arrived at majority-vote and deep-ensemble methods, credit the prior art, and then show why a vote is so well suited to a one-pixel well-log curve, where one model's miss is exactly the gap another model can fill. The interesting question is never whether the ensemble is steadier (it is) but whether the extra inference cost is worth a single-vote of recall, and we walk the vote threshold from union to consensus to make that trade legible against our own measured per-curve F1 spread of 0.37 on curve 1 and 0.32 on curve 2.

Static vs Dynamic Image Logs: A 25x Class-Error Drop from Data Choice Alone

Swapping the input representation from static to dynamic borehole image logs — with the same Detection Transformer, the same weights, the same training recipe — cut fracture classification error from 63.45% to 2.536%, a roughly 25x improvement. The model never changed. The data did. And for vugs, the choice reverses.

Transformer Architectures for Dense Prediction on Document Images

A period-correct survey of how transformer and attention-based dense-prediction backbones came to differ from the convolutional U-Net lineage, read specifically through the lens of document imagery rather than natural photographs. We credit the public lineage in full, from the attention mechanism and the plain Vision Transformer through the first segmentation transformers, the pyramid and window variants that restored multi-scale structure, the dense-prediction transformer that reassembled tokens into a per-pixel head, and the mask-classification reformulation. Against that map we situate our own configuration, a residual convolutional encoder and decoder of five stages each with only two self-attention refinement layers at a 128-dimensional bottleneck, and argue that for a single-channel, scarce-label, document-style raster the right amount of attention is a small amount placed where it pays, not a transformer in place of the convolution. Our raster well-log digitisation work is the running test case, with synthetic segmentation sets of 2,000 binary and 15,000 multiclass instances on an 80/20 split and a 0.51 peak multiclass IoU we read as a data ceiling rather than an attention deficit.

Two Attention Layers on the Bottleneck: How Much the Transformer Block Actually Bought Us

A close reading of one architectural detail in a raster well-log segmentation network: the two transformer self-attention layers that sit on the U-Net bottleneck, between the deepest encoder stage and the first decoder stage. The post separates that block cleanly from the two things it is constantly confused with, the channel-and-spatial CBAM attention that gates each convolution stage and the copy-and-concatenate skip connections that carry detail across the U, and traces what bottleneck self-attention is actually for: long-range feature mixing at the one resolution small enough to afford the quadratic cost. It credits the period-correct lineage, from the original transformer through the vision transformer to the hybrid convolution-plus-attention U-Nets of 2021 and 2022, and uses the network's own five-stage, 128-dimension, three-class configuration as the worked example.

The First Three Hundred Steps: Why Batch-of-One Training Needs a Warmup

A linear learning-rate warmup over the opening few hundred steps is the cheapest insurance against early divergence, and it matters most precisely where we lived: a batch size of one. With a single raster log per step the gradient is a noisy sample of one, and a cold full-rate start can throw the loss off a cliff before the running statistics ever settle. This is a narrow primer on the warmup ramp itself, the opening segment of the schedule and not the whole thing, on our 2000-instance binary segmentation run for VeerNet. The warmup recipe is not ours and we credit it; the worked reading at batch size 1 is.

When GANs Lose: Why KNN Beat GAN/GAIN for Image-Log Gap Imputation

A generative adversarial imputer is the sophisticated choice for filling the pad gaps in high-resolution borehole image logs — and it lost. On a 14-well Middle East carbonate program we ran, GAN/GAIN inpainting broke the one invariant that matters downstream, sinusoid continuity, while a five-neighbour KNN imputer preserved it at a fraction of the compute. This is an ML-engineering postmortem on why the fancy model was the wrong tool, and the model-selection rule it leaves behind.

Active Learning to Spend Your Annotation Budget Wisely

A labelling budget is money, and most of ours was being spent re-confirming a background the model already scored 0.94 IoU on while the two curve classes sat at 0.26 and 0.21. This note is about treating model uncertainty as the spending signal: reading which classes the model is least confident about, and routing the next label there rather than spreading effort evenly. It is deliberately not a reprise of the VeerNet whitepaper's dataset-growth story. Growing the corpus from 2,000 to 15,000 synthetic instances was one lever; this is a different one, about where inside a fixed budget the marginal label lands. We tie the priority to calibration rather than raw count, because a model that is badly calibrated will point you at the wrong class, and we are honest that the return curve we sketch is a labelling-return argument, not a logged active-learning experiment. The per-class scores, the instance counts, and the class_weight of 42 are the real archive numbers; VeerNet, the digitiser whose confidence we read, is ours.

Why a Smaller Backbone Won: ResNet-10 Beat ResNet-34 by 50x on Class Error

On a 14-well geoscience dataset, a from-scratch ResNet-10 backbone posted a 0.50 classification error while ResNet-34 sat at 26.76 — a 50x gap that is not noise. When labelled data is the bottleneck, a heavier feature extractor overfits before the rest of the model can learn, and the ablation table is the only honest way to find out.

AI in geology: transforming noisy curves into instant insights

How transformer-based deep learning — the same architecture family that powers ChatGPT and Vision Transformer — applies to one of the upstream industry's most stubborn problems: turning decades of scanned raster well-log images into clean, queryable digital curves. A condensed companion to the VeerNet AI whitepaper.

The Accelerator Gauntlet: What Investor Readiness Gating Demands

A structured accelerator does not hand out investor-readiness at demo day. It gates it, behind a stack of thresholds that all have to clear before a startup is allowed in front of capital: 80% of 100-plus curriculum hours, five of six mastermind sessions, a floor of pitch-deck reviews and coaching workshops, and a pre-IR audit that will not pass a bloated elevator pitch. We spent six months inside that gauntlet while also building the actual product, and the useful thing we learned was not any single lesson from the curriculum. It was that the gating itself is a forcing function: because the gates are an AND, not a menu, they impose a schedule on the founder work that founders reliably defer, and they do it in parallel with the engineering that never pauses. This is a note on what that parallel pressure demands and where it actually helps, told from the product side rather than as an architecture story.

AdamW vs Adam vs SGD on a 14-Well Transformer: Why the Optimizer Is a Lever, Not a Footnote

When you train a Detection Transformer on a handful of wells, the optimizer stops being boilerplate. In our work with a mid-sized Middle East carbonate operator we swept SGD, Adam, and AdamW on a 14-well fracture-picking transformer — and AdamW won. This is the engineering story of why decoupled weight decay matters most exactly when data is thin, and how it sat inside a deliberately small training recipe: batch 128, a 0.001→0.0005 learning-rate sweep settling at 0.0004, dropout 0.2, and early stopping after 40 epochs of no improvement.

Multi-Scale Feature Extraction for Document Image Segmentation

A computer-vision primer that maps the multi-scale feature-extraction literature onto the encoder-decoder shape, using document image segmentation as the worked case. The organising problem is one of scale mismatch: the structure to recover on a scanned well log can be a single-pixel-wide curve, while the page it sits on runs up to 12800 pixels across, so useful features are needed at many scales at the same time. We trace how the field learned to grow the receptive field, from the symmetric encoder-decoder with skip connections, through dilated convolution, spatial pyramid pooling, and feature-pyramid fusion, and we credit the receptive-field analysis that shows why a stack of convolutions integrates far less of the page than its nominal depth suggests. That gap is the reason attention entered the encoder-decoder: on the smallest, most-downsampled map, the bottleneck, a couple of transformer layers give genuinely global context that the convolutions never reach on their own. We situate our own configuration on that map, 5 encoder stages and 5 decoder stages, a 128-dimensional embedding, 2 attention layers on the bottleneck, and 3 output classes over inputs 3200 to 12800 pixels wide, and argue it is a period-correct answer to the multi-scale problem rather than a new one. This is a survey of the public field; the architecture numbers are ours and are used as a concrete anchor, not as a benchmark.

Few-Shot and Small-Data Vision: A Reading List for 2023

A practitioner's reading list for the label-scarce regime, ordered by the one thing that decides whether the reading pays off: realised leverage on a real pipeline. The short version is uncomfortable for anyone who came for the exotic few-shot tricks. On raster well-log digitisation, where hand-drawn per-pixel masks are exactly the labels nobody wants to draw, the payoff did not come from a clever k-shot method. It came from manufacturing data and reusing representation: procedural synthesis scaled from 2,000 to 15,000 to 20,000 instances, an autoencoder warm-start, and the plain discipline of an honest 80/20 split, run through a batch-size-1, memory-constrained pipeline to a peak held-out R-squared of 0.9891 and a lowest MAE of 0.0132. This is the list we would hand a team starting from a few hundred labels, arranged so the highest-leverage reading is not buried under the most-cited. It is a companion to, not a repeat of, our survey of few-shot segmentation method families; that piece maps the borrowed-support world, this one argues for the manufactured-support one.

Dataset Distillation and Coreset Selection: Training on Less Without Losing Accuracy

A survey of the two ways to train on a smaller set without giving up accuracy, read against our own raster well-log digitiser VeerNet. Coreset selection keeps a chosen subset of real training instances; dataset distillation synthesises a tiny set that stands in for the whole. We trace both to their published origins, separate the selection rules the literature converges on, and use them to frame a measurement question our own numbers pose: our multiclass model reaches a peak R-squared of 0.9891 on 15,000 synthetic logs trained in 550 minutes, while a related binary task needs only 2,000 instances and 110 minutes, so where does the retention curve for the larger set actually bend. The central finding is that a well-chosen coreset preserves accuracy on a plateau while cutting wall clock, and that the useful survey question is not whether to shrink the set but how far it shrinks before the goodness-of-fit degrades. This is a survey of the published field; the engagement numbers are ours and are used as a worked measurement anchor, not as a new benchmark.

OSDU in Plain Language: What the Open Subsurface Standard Means for Data Teams

An explainer, from the receiving end, of what an open subsurface data standard actually does and does not do for a team that has to load its own archive into it. OSDU standardises how a well-log curve is described, named, and retrieved once it exists as depth-indexed numbers. It does not manufacture those numbers. When we looked at a real archive it was 136,771 TIF scans against 7,781 LAS files, so most of the corpus was pixels, not curves, and even the digital side arrived with three different null conventions (-999, NA, None) that a standard alone will not reconcile. The point of this note is the seam the standard leaves for you: something still has to turn the raster into machine-readable curves interpolated to a common depth grid, keyed to canonical track groups, before OSDU has anything to catalogue. We walk through the standard in plain terms, then through the one step it presupposes, using the digitiser behind VeerNet as the concrete example of that step. It is deliberately not a VeerNet walkthrough; it is a map of where an open standard starts paying off and what has to happen first.

Air-Gapped and On-Prem Model Serving: A Survey for Regulated and Sensitive Domains

Managed cloud serving is the default the machine-learning-operations literature was written for, from the technical-debt accounting of Sculley and colleagues through the prediction-serving systems of Crankshaw and colleagues and Olston and colleagues to the deployment-case survey of Paleyes and colleagues. Regulated subsurface data breaks that default: when an operator's raster archive cannot leave a boundary it controls, the model has to be served where the data already sits. This survey reads the serving-posture question as a matrix of four postures, public serverless, private virtual private cloud, on-prem, and fully air-gapped, scored on data residency, latency, and operations burden, and grounds it against a real reference footprint from our raster well-log digitiser, VeerNet: a batch-of-one, single-channel model with GroupNorm groups of 16 and five encoder plus five decoder stages. The central finding is that moving off the public cloud recovers residency control at a real cost in operational convenience, and that on-prem and air-gapped postures buy most of that convenience back only when the served model is small enough for one card in a locked room, which is exactly what a batch-of-one dense-prediction network is. The public works and systems belong to their authors; the reference footprint is ours and is used as a worked example, not as a benchmark.

Data Augmentation Policies Learned and Hand-Tuned: A Survey Across Vision Tasks

A field-education survey of how augmentation policies are chosen, separating two traditions the literature runs together: learned policies that search over transform choices with an outer optimiser, and hand-tuned stacks that a practitioner sets by inspection. We trace the learned line from AutoAugment through Population Based Augmentation, Fast AutoAugment, RandAugment, and TrivialAugment, and read it against the hand-tuned tradition of simple geometric and photometric transforms plus random erasing. The reading is grounded in a real small-data dense-prediction baseline from our raster well-log digitiser, VeerNet: a five-transform hand-tuned stack of sharpness, blur, jitter, perspective, and random erasing, trained on 15,000 synthetic multiclass instances at an 80/20 train-validation split, with perspective and erasing carrying the bridge to 136,771 real scans. The central finding, which the field's own later results converge on, is that most of the sim-to-real robustness a learned search promises can be bought by a short hand-tuned stack at a fraction of the search cost, and that the marginal robustness a full policy search recovers is often small relative to the trial-run budget it spends. This is a survey of the published field; the engagement numbers are ours and are used as a worked example, not as a new benchmark.

A Spin-Out Story: Turning Consulting Work Into a Product Company

A research consulting engagement does not become a fundable product company in one move. It converts by clearing three gates in order, and the order is load-bearing: first a working pipeline built as delivery work, then external demand proof, then an investable structure, with each gate de-risking the next. This is the product story behind VeerNet rather than the architecture: how a paid delivery engagement of 16 weeks with 6 people at 180,000 EUR, or 32 weeks with 4 at 100,000 EUR, became the research substrate under a venture; how 3 Letters of Intent turned an internal belief into an outside signal; and how a cap-table fact, 50 percent equity issued to the research firm on a fully-diluted basis over a three-year term, made a 3,000,000 USD seed ask with 18 months of runway a thing an investor could actually price. We are honest about which of those steps we got in the right order and which we would run differently.

Focal+L1 vs Cross-Entropy: Choosing the Loss for Imbalanced Sinusoid Classes

Why a focal classification loss paired with an L1 parameter loss beat class-weighted cross-entropy for picking bedding and fracture sinusoids on borehole image logs — and why the right loss, its confidence threshold, and its term weights are a data-imbalance decision, not an architecture footnote.

Why a 0.51 IoU Can Still Ship a Useful Product

A segmentation model that scores 0.51 IoU reads as a failing grade if you stop at the mask. But the mask is not the product. On the curve-digitisation task behind VeerNet, the thing a petrophysicist actually uses is a depth-indexed curve recovered from that mask by centreline extraction and spline validation, and on the Tversky curve-1 example that recovered curve fits the reference at R-squared 0.9891. This is a note on the metric-to-utility gap: why a pixel-overlap score of 0.51 and an F1 of 0.55 can sit under every instinct about what good looks like while the recovered curve, carried by recall up to 0.97 and 300 interpolated depth points, still clears the bar the product is judged on. The overlap metric measures how well two masks agree pixel-for-pixel. The product measures whether the curve is right. Those are not the same question, and treating the first as a proxy for the second is how a shippable model gets discarded at the review meeting.

Chart Data Extraction: Datasets, Tasks, and Methods in the Literature

Reading numbers back out of a chart image is its own research subfield, with public datasets, a settled task taxonomy, and a decade of methods. This survey maps that landscape and credits the groups who built it: Scatteract for scatter plots, ChartOCR and PlotQA across mixed chart types, the ICPR 2020 CHART corpus for structured chart parsing, and LineEX for line charts. We then place raster well-log digitisation inside the same map. A scanned well log is the same raster-to-data problem the chart community solves, but it is a hard and under-benchmarked instance of it: only three output classes against a much wider input than any public chart figure, 3,200 to 12,800 pixels, scored at 300 interpolated depth points. The contribution is the positioning, not a new dataset, and the credit for every public corpus belongs to its authors.

Calibrating the Depth Axis: Mapping Pixel Rows to True Measured Depth

A digitised well-log curve is only as trustworthy as the depth it is plotted against, and depth is the one quantity a scanned image does not carry in its pixels. It lives in the header scale, where two printed depth ticks anchor the vertical axis. This study treats depth-axis calibration as its own evaluation problem, separate from curve interpolation: how a detected pixel row is mapped to a true measured depth through an affine fit on those two anchors, and how an error in reading either anchor propagates into the final CSV. We model the propagation analytically, validate it against the 300 interpolated depth points used in the engagement, and place it next to the model's own error floors of 0.0132 MAE and 0.0004 MSE. The finding is that a calibration slip is not a constant offset but a slope tilt: a residual that is zero at the top anchor and grows linearly to the deepest sample, so the error a header-read mistake injects is largest exactly where the formation of interest usually sits.

Reproducibility and Experiment Tracking in a Small Research-ML Team

Reproducibility in machine learning has a public literature and a public toolchain, from Gundersen and Kjensmo's audit of how little top-conference work could be regenerated, through the NeurIPS reproducibility program, to experiment-tracking infrastructure like Sacred and the variance accounting of Bouthillier and colleagues. This survey reads that literature and then grounds it in our own small-team practice on a raster well-log digitisation project. We describe how we pinned the five-loss-function ablation matrix (Dice, Focal, Lovasz, Soft CE, Tversky), the random seeds, the dataset version, and the run provenance so that a curve-1 R-squared of 0.9891 logged on the 15,000-instance multiclass corpus could be regenerated months later. The contribution is the practice report and its placement in the field, not a new method; the public works and tools belong to their authors, and VeerNet, the digitiser whose runs we tracked, is ours.

Lightweight Attention for Single-Curve Digitisation with CBAM

Attention has a reputation for being expensive, and on a small U-Net trained to lift a single curve off a scanned log that reputation is enough to scare people off it entirely. It should not. The Convolutional Block Attention Module of Woo et al. bolts channel and spatial attention onto any feature map for almost nothing: a two-layer MLP bottleneck on the channels and a single convolution on a pooled spatial map. At a 128-dim feature depth the whole block adds a few thousand parameters, a rounding error against the backbone, while giving the network a way to decide which channels and which pixels matter before it commits to a mask. This is a practitioner's primer on how the two knobs work, what they cost, and how to set them when your target is one thin curve.

Skip Connections as Memory: Recovering Detail in the Decoder

An encoder-decoder built to lift a single thin curve off a scanned well log has a structural problem that no amount of depth fixes. Five stride-2 stages contract the image down to a coarse 128-dimensional bottleneck, and by the time the trace reaches that bottleneck the one-pixel structure the segmenter must reproduce has been pooled into a blur. The decoder then has to put it back. The instinct is to make the decoder deeper or the bottleneck richer, but that is the wrong lever: a deeper decoder still only has the smoothed code to work from. What actually restores the single-pixel detail is the skip connection, which hands each decoder stage the matching-resolution encoder feature map it lost. This piece walks through why high-frequency detail dies at the bottleneck, why depth does not bring it back, and why skips, introduced in U-Net and explained by the residual-learning literature, are the memory the decoder reads from.

Inference Output Storage: Writing Results Back to S3 Cleanly

Everyone specs the model. Almost nobody specs the step after it: how a predicted mask and its derived CSVs actually land in object storage so that the next process can read them without guessing. This is a field note on the part of a serverless deployment that breaks most often, and it is not the network. It is the output contract. We credit the storage and ML-systems literature that named the failure modes, and describe the small set of rules that made our writeback deterministic for a raster-log digitisation service.

Optimisers and learning-rate schedulers: a practical deep dive

Why the choice of optimiser (SGD, Adam, RMSprop) and the shape of your learning-rate schedule (step decay, exponential, cyclic) often matter more than another 1% of model capacity. A webinar recap, with the live optimiser-trajectory plot we built to make these trade-offs visible.

Synthetic Data for Scientific-Image Segmentation: What the Literature Got Right

A research note pairing our own sim-to-real result on raster well-log digitisation with the public literature on synthetic and procedurally generated training data for scientific and document image segmentation. We trained VeerNet entirely on procedurally generated logs and read curves off scanned rasters it had never seen. The field had already explained why that should work; our numbers say where it stops.

Keypoint Detection vs Direct Dip/Azimuth Regression: The Depth-Angular Trade-Off

Two heads, one transformer. Regressing dip and azimuth directly nails the angles but leaves a stubborn vertical depth shift; reconstructing them from picked keypoints fixes depth at a small angular cost. The choice is bounded by hard physics — a 2 cm true-positive tolerance and the 1 px = 3 cm digital-log-format limit — and it comes down to which axis your geologist actually grades you on.

KNN vs GANs vs Interpolation: Filling the Gaps in Borehole Image Logs

High-resolution borehole image logs from two different microresistivity imaging tools ship with systematic pad gaps — null columns where the tool circumference outruns electrode coverage. We benchmarked four ways to fill them — KNN imputation, GAN inpainting, an iterative imputer, and 1D linear interpolation — for one property that actually matters downstream: does the sinusoid stay continuous across the gap? The simplest method won.

Classical CV vs Deep Learning for Carbonate Vug Quantification

For per-vug quantification on carbonate image logs, a classical computer-vision pipeline still wins on the two things petrophysicists actually need — speed (15 s/m vs 5 min/m, a 20x edge) and interpretable per-vug statistics (area, circularity, resistivity) — while matching ~85% expert agreement. Here is why deep learning is the bridge, not yet the replacement, and where the handoff happens.

Sim-to-Real Demystified: Training on Fakes

A plain-English primer on why a model trained entirely on synthetically generated well logs can read real scanned ones, and why the transfer is never perfect. We generated our curve-segmentation training set by drawing fake logs rather than labelling real ones, then asked the model to work on genuine scans it had never seen. The intuition that makes this reasonable is that a model learns the shape of the task, not the individual pictures, so a generator that covers the right variety of shapes teaches most of what a real archive would. The intuition that keeps you honest is the reality gap: the part of the real distribution the fakes never contained, which no amount of generator polish invents. This note explains the gap, what shrinks it and what does not, and how to reason about a synthetic pipeline before you trust it. It complements our VeerNet pipeline write-up rather than repeating it; the pipeline is the how, this is the why.

Physics-Informed Machine Learning in Subsurface Modeling: A Survey of the Field

A survey of the physics-informed machine-learning methods used in subsurface modeling, read as one ordered family rather than a pile of acronyms. We separate five approaches by what they do with the governing physics: PDE-constraint schemes that fold the equation into the training loss (physics-informed neural networks), reduced-order models that project a full-order solve onto a small basis, neural operators and DNN surrogates that learn the solution map from simulator runs, hybrid physics-plus-data methods that keep a prior and learn the residual, and pure data-driven nets that keep no physics at all. Laid out on a single spectrum from physics fidelity to data efficiency, the families stop competing and start slotting into the regime each is good for, and the reported inference-speed payoff turns out to concentrate toward the surrogate and data-driven end: a reservoir-engineering DNN surrogate at 200x to 2,000x over a conventional simulator, a gradient-boosted production forecast at 100x or more, a geological-assessment DNN claiming up to a millionfold over manual mapping, and roughly 20 percent drilling cost savings, all from the same period upstream survey. This is a reading of the published field and credits the prior art that defined it; it is not a reprise of our own VeerNet architecture paper, and the acceleration figures are period-correct reported numbers, not our own benchmark.

Designing Synthetic Data That Generalises, Not Memorises

When you train a curve-segmentation model on synthetic well logs, the generator is the teacher, and a model can only ever be as general as the variety its teacher shows it. This is a practitioner's note on the design decision that decides whether the model learns the subsurface or just learns our generator: how wide we make the generator's variety in curve width, shape, and artefacts. We scaled the synthetic corpus from 2,000 binary instances to 15,000 multiclass instances and 20,000 two-curve logs, spanning widths from 3,200 to 12,800 pixels and heights from 480 to 640 pixels on an 80/20 train/validation split. A high validation score on that split is necessary but not sufficient, because validation is drawn from the same generator; the real test is the gap to unseen scans. This note is about designing the diversity axes so that gap closes, and it is deliberately not a reprise of the VeerNet pipeline itself.

Mask-Free DETR vs Mask R-CNN for Borehole Feature Picking: Why a Capability Matrix Beats a Single Accuracy Number

The published Mask R-CNN baselines for borehole feature detection post strong headline scores — mIoU 81.2%, precision 96%, recall 92% — yet still cannot retrieve intersecting fractures, estimate dip and azimuth end-to-end, or run without hand-tuned post-processing. We compare a mask-free Detection Transformer against those baselines on the capabilities a petrophysicist actually needs, and argue that the right axis of comparison is a capability matrix, not an accuracy leaderboard.

Engineering Drawing Interpretation: A Survey of Symbol and Line Recognition

A survey of how the literature reads engineering drawings, organised around a split that turns out to be load-bearing: interpretation separates into discrete symbol recognition, a detection-and-classification task on bounded shapes, and continuous-line tracing, a thin-structure segmentation task. We trace the symbol half from classical template and graph-grammar methods to learned detectors, and the line half from vector tracing and edge linking to pixel segmentation. The argument we care about is that the line half is not a cousin of our own raster well-log curve digitiser but the same problem: a few-pixel foreground overwhelmed by an easy background. We read that against a real anchor from our multiclass log run, where the fat background mask reaches an intersection-over-union of 0.94 while the two thin curves reach only 0.26 and 0.21 under the same Dice-trained three-class model. This is a survey of the published field and a positioning of our own thin-structure work next to it, not a new benchmark; the engagement numbers are ours and are used as a worked reference point.

The Value Locked in Old Paper Logs, and Who Is Trying to Free It

Well logs from decades of drilling still sit as scanned raster paper, TIF and LAS images that a computer cannot read as curves. A single public regulator archive holds 136,771 TIF and 7,781 LAS scans, and that is one archive of many. The market this feeds is large, a 6.7B USD O&G software slice inside a 134B USD transactions market, but freeing the archive is a data-recovery problem rather than a data-access one, and the players with the deepest data moats have mostly left it alone. This is a note on who touches the stranded raster archive, why moat depth does not equal recovery capability, and where a digitisation challenger wedges in. It is deliberately not a walkthrough of VeerNet, the model itself; it is the market around it.

Active Learning on a Budget: How Teams Decide What to Label Next

Active learning is a well-charted map of acquisition functions, from Lewis and Gale's uncertainty sampling to Settles' survey of the whole family. This is a field note on where one pragmatic, small-data choice sits on that map: generate cheap synthetic labels first, then spend scarce human annotation only on the handful of hardest real scans. We credit the lineage and claim only the budget point we actually occupy.

Borrowing Structure From Unlabeled Logs: Autoencoder Pretraining for Sparse Masks

A scanned well log is mostly texture, gridlines, header boxes, and ink that the network can study without a single label. A sparse curve mask is the opposite: a few thin strokes that are expensive to annotate and brutal to learn from cold. This is a primer on a reconstruction-first recipe that bridges the two. Warm-start the encoder as an autoencoder on unlabeled log images so it learns log texture first, then fine-tune the same backbone for mask prediction. We survey the lineage that makes this work, from stacked autoencoders to masked image modelling, credit it honestly, and describe only the curve-segmentation point our own VeerNet system actually occupies, where the thin-curve IoU sits at a 0.26 and 0.21 floor when the encoder starts cold.

Few-Shot Semantic Segmentation: Methods, Benchmarks, and the Small-Data Frontier

A survey of few-shot semantic segmentation across its three working families - matching networks, prototypical methods, and meta-learning - and an honest reading of what the PASCAL-5i and COCO-20i benchmarks reward. We credit that prior art in full, then position our synthetic-first route as the orthogonal answer to the same small-data problem: instead of borrowing a tiny labelled support set, manufacture one and never touch the k-shot axis at all.

GroupNorm Over BatchNorm: Normalising When Your Batch Size Is One

When variable image dimensions pin your training batch at a single image, BatchNorm has nothing to average over and its running statistics collapse onto one sample. We credit the normalisation literature that anticipated this exactly, then report the practical rule that kept activations stable across wildly different raster-log sizes: switch to GroupNorm and floor the group size with a half_or_16 heuristic, so the normaliser reads per-image statistics and never depends on the batch dimension at all.

Erasing the Grid: Graticule Removal as a Domain-Knowledge Preprocessing Step

A scanned well log carries two kinds of dark ink: the logging curve, which is signal, and the printed graticule of track borders and depth grid lines, which is furniture. A naive segmenter cannot tell them apart, because at the pixel level a grid line and a curve are the same thing, a dark stroke on light paper. The document-image literature has spent decades separating ruling lines from content, from morphological line removal to Hough-based detection to learned text and graphics separation. This post surveys that lineage, credits it, and then makes one engineering claim that is ours: because we know exactly what a well log is supposed to look like, we can strip the periodic grid before VeerNet ever sees a pixel, and that single prior turns a hard segmentation problem into a merely difficult one.

Self-Supervised Pretraining for Dense Prediction: A Survey of Pretext Tasks

A survey of the pretext-task literature for dense-prediction pretraining, read through three working families: reconstruction pretexts (inpainting, colourisation, jigsaw, rotation), instance-contrastive learning (SimCLR, MoCo, BYOL, DINO), and masked-image modelling (BEiT, MAE, SimMIM). We credit that prior art in full, then ask the question that actually matters for our setting: which of these transfer to a small, document-style scientific dataset rather than to internet-scale photographs. Our raster well-log digitisation regime is the test case, with synthetic training sets of 2,000 binary and 15,000 multiclass instances on an 80/20 split and a 0.51 peak IoU ceiling that better initialisation is meant to lift. This piece is distinct from our earlier few-shot survey: that one was about borrowing labels, this one is about borrowing representations.

The Quiet Work of Standardising NaN Across Messy Log Files

Before any petrophysical model can train, somebody has to decide what a missing reading looks like, and a real corpus of digitised logs almost never agrees with itself. The same absence shows up as a numeric NULL sentinel, an empty cell, the literal text NaN, a stray N/A, a zero pressed into service as a stand-in. This is a primer on the unglamorous step that has to happen first: collapsing every disguise of absence to a single machine-readable null so a missingness audit stops lying to you. We survey how the data-quality and petrophysical-tooling literature framed the problem, credit the people who built the libraries, and describe only the housekeeping our own VeerNet pipeline did on its 7781-file corpus, where the public Norwegian-Sea tutorial slice of 118 wells and 22 measurement columns makes a useful, inspectable mirror.

Why Thin-Structure Segmentation Is Harder Than It Looks

A one-pixel-wide curve makes overlap metrics brutally unforgiving. On our own raster-log digitisation run the thick background mask hit IoU 0.94 while the two thin curve masks sat at 0.26 and 0.21 under the same Dice loss in the same model. The gap is not a training failure. It is geometry: when the target is one pixel wide, a one-pixel prediction error is a total miss, so IoU collapses for reasons that have nothing to do with how well the model understood the curve.

Why DBSCAN and Hierarchical Clustering Couldn't Separate Sinusoids — and Supervised DETR Could

Picking fracture sinusoids on borehole image logs looks like an unsupervised clustering problem — until you try it. In a roughly twenty-month engagement with a mid-sized Middle East NOC carbonate operator we partnered with, DBSCAN needed more than 10,000 parameter combinations and was still 'very unstable', and hierarchical clustering ran out of memory on a 50 GB Colab machine while demanding the correct cluster count in advance. This is the engineering story of why the pipeline abandoned unsupervised methods and pivoted to a supervised Detection Transformer — and what that pivot bought.

1D Interpolation vs KNN Imputation: A 20x+ Speedup Benchmark for Well Logs

A profiling deep-dive into why filling NaN gaps in high-resolution borehole image logs with 1D periodic interpolation ran ~23x faster than a KNN imputer — and finished a whole well in ~11 s where KNN never finished at all. The speed gap is an algorithmic-complexity story, and the punchline is that quality-equal methods can differ by orders of magnitude in cost.

Keypoint Reconstruction to Fix the Vertical Depth Shift in Sinusoid Localization

Direct depth regression left a stubborn vertical shift in our borehole-fracture detector — picks that were geometrically right but landed a centimetre or two off in depth. A keypoint-detection post-processing stage that reconstructs the sinusoid from its peak, trough, and zero-crossing fixed the depth error, at a small cost in angular accuracy, all against a hard 1 px = 3 cm log-resolution floor.

Seismic facies analysis with deep domain adaptation — IEEE TGRS 2022

Published in IEEE Transactions on Geoscience and Remote Sensing (60, 1–16, 2022, Art no. 4508116). EarthAdaptNet + CORAL — a deep-learning architecture that classifies seismic facies in a target basin using only labels from a source basin. Pixel accuracy >84% on F3, ~99% peak class accuracy on Penobscot transfer.

Reading a Transformer's Mind: Attention Rollout on Borehole Image Logs

A practitioner's guide to attention rollout — average the heads, add an identity matrix, recursively multiply across layers — and what it takes to turn a Detection Transformer's encoder self-attention into a geologist-readable saliency map over a sinusoid, plus the honest caveat about where the technique stops working on a borehole image log.

Path-Opening Across 39 Thresholds: Recovering Sinusoids Where Hough and Canny Fail

A computer-vision deep-dive on morphological path-opening as an unsupervised baseline for borehole fracture picking. Swept across 39 connectivity thresholds, path-opening recovers three distinct sinusoids in a densely fractured carbonate section where a Canny–Hough pipeline collapses into noise — and it does so before a single label is drawn, setting the floor a supervised Detection Transformer has to beat.

Counting on the Background: the class-imbalance trap in multiclass log segmentation

In a scanned well log the curve pixels are a sliver of the frame and background is everything else, so a segmentation model that predicts background everywhere scores beautifully and learns almost nothing. We walk the class-weighting fix and the per-class F1 spread it leaves behind.

Optical Music Recognition as a Raster-to-Symbol Problem

Optical music recognition and raster well-log digitisation look like separate crafts, but they are the same class of problem: dense, thin symbols drawn on structured, ruled paper, where the ruling is furniture and the ink that matters is a hair-thin foreground occupying a few percent of the pixels. This survey reads the optical-music-recognition literature - its staff-line detection and removal, its symbol classification, its habit of treating the ruled substrate as a preprocessing problem before recognition - and shows that each stage has an exact twin in curve extraction from scanned logs. We ground the parallel in our own numbers from an adjacent well-log run: a 3-class segmentation over 15000 synthetic instances where the thin foreground is about 3% of the pixels and the multiclass model reaches a peak intersection over union of 0.51, a peak F1 of 0.55, and a peak recall of 0.97. The central claim is that the recall-heavy, precision-light shape of those numbers is not a quirk of well logs; it is the signature of the whole raster-to-symbol family, and optical music recognition diagnosed it decades earlier.

The Bipartite Matching Loss: How Transformers Learn to Pick Fractures

A technique deep-dive on the Hungarian bipartite matching loss that lets a Detection Transformer assign predicted queries to ground-truth sinusoids on borehole image logs — with no anchors and no NMS — and why set prediction is the right inductive bias for fracture picking.

Document AI for Engineering Archives: Methods Across Scanned Charts, Maps, and Logs

A landscape survey that reads three engineering-archive domains, scanned charts, cartographic maps, and strip well logs, as three faces of one raster-to-structure problem. We credit the published lineages that each domain built on its own, from parameter-space line voting to fully convolutional segmentation, and argue that beneath their different vocabularies they share a single four-stage recipe: segmentation, centreline extraction, calibration, and vectorisation. We ground the recipe on our own well-log instance, where a 136,771-TIF raster archive is resolved to a 3-class output, background plus two curves, resampled to 300 interpolated depth points by an encoder-decoder of 5 stages each with 2 attention layers. The claim is that the shared spine, not the shared architecture, is what transfers between adjacent archive domains, and that most of the recipe after segmentation is geometry rather than learning.

What a Letter of Intent Really Proves at Pre-Seed

A signed letter of intent is the most over-read artefact in a pre-seed deck. It is a genuine signal and a bounded one, and the two facts get collapsed the moment a founder or an investor treats a short stack of letters as revenue that has not been booked. This is a field note on what a letter of intent actually carries as an early demand signal and what it does not: it proves that a named buyer feels the problem and that the interest spans more than one kind of buyer, but it does not set a price, sign a contract, or promise a seat. We read it against a real pre-seed spread, three letters from four buyer types, a 6.7 billion dollar serviceable market, and a 1,200 dollar per-seat list price the letters never validated, and argue that the right way to read a small letter count is as a demand vector, a direction with real information in it, never as traction on the books.

Reading IoU and Dice Scores Without Fooling Yourself

A short methods note on how to read an overlap metric on a thin-curve digitiser without letting it flatter you. A single headline IoU or Dice number is a blend, and on a raster well log the blend is dominated by the one class that is trivial to segment: the background. On VeerNet, the encoder-decoder EarthScan uses to lift curves off scanned logs, a background IoU of 0.94 averages with curve IoUs of 0.26 and 0.21 to produce a peak of 0.51 that reads far healthier than the model is on the pixels that carry the signal. This is not about abandoning overlap for a better metric; it is about reading the overlap metric per class, so the average cannot hide where the model actually lives.

Padding to a Multiple of 32: Small Detail, Big Inference Bug

A short MLOps war story about a segmentation model that trained beautifully, passed validation, and then quietly produced torn masks the moment it met a real scanned log. The cause was not the network or the data. It was thirty-two pixels of padding that the training loader added and the inference path forgot. This post traces how a single missing preprocessing step turns a clean encoder-decoder into a silent failure, why no exception is ever thrown, and why the fix is one line that snaps the input width up to the next multiple of 32.

Active Learning for Pixel-Level Tasks: A Decade of Acquisition Functions

Acquisition functions were built to rank whole examples, but dense prediction asks the question one pixel at a time, and on a thin-curve task almost every pixel is trivially background. This survey traces a decade of acquisition design, from Lewis and Gale's uncertainty sampling through margin, entropy, BALD, and the core-set reframing, crediting each to its origin, and asks which of them survive the move to a pixel-level objective where 97 percent of the labels carry no signal. We ground the question in a measured regime from our own VeerNet pipeline, a three-class log segmenter whose curve-1 and curve-2 F1 sit at 0.37 and 0.32 across a scale-up from 2,000 to 15,000 training instances. The thread that runs through the decade: every acquisition function is a theory of where the model is wrong, and on a dense imbalanced task that theory has to survive being averaged over a near-empty image.

A Field Guide to Annotating Synthetic Logs With Realistic Noise

A practitioner's guide to one decision that quietly governs whether a synthetic raster well log earns its keep: how much, and what kind, of scan noise you bake in before the mask ever sees it. We walk the four degradations worth modelling (page skew, ink bleed, grid jitter, paper and scanner grain), explain why a perfectly clean synthetic label teaches the wrong thing, and show how realistic noise turns a flattering label IoU into one calibrated to survive the 0.51 ceiling real scans impose. The pixel target is one to three pixels wide, the generator renders logs from 3,200 to 12,800 pixels across with a constant two curves per log against a three-class mask, and the trade we keep returning to is robustness over a number that looks good in a notebook.

How Wide Can an Input Be? Designing for 12800-Pixel Images

A raster well log is not a tidy 224 by 224 tile. Its width runs from about 3200 to 12800 pixels while its height barely moves, and that one lopsided fact decides how many images you can fit in a batch before the GPU runs out of room. This is the engineering story of why fixed resizing was the wrong reflex, why a custom collate_fn that pads to the widest member on a 32-pixel grid let the multiclass pipeline hold batch 16 while the binary one stayed stuck at batch 1, and how the encoder's five stride-2 stages quietly set the alignment rule.

Label Noise in Real-World Segmentation: Sources, Measurement, and Robust Training

A survey of where pixel labels actually go wrong in real scientific-image datasets, how the corruption is measured, and which robust-loss and sample-reweighting strategies the public literature shows can tolerate it. We sort the noise into annotation, propagation, and rasterisation sources, review the noise-robust training families published through 2022, and ground the survey in a worked example from our own VeerNet pipeline: a weighted binary segmenter that holds recall at 0.96 to 0.97 while its F1 collapses to 0.37, 0.26, and 0.55, the high-recall low-precision signature that label noise amplifies. The pattern that holds across the field: a loss that trusts every label equally trusts the wrong ones hardest.

Selling Software to a 134 Billion Dollar Market: Sizing TAM Honestly

A headline total addressable market is the easiest number in a pitch deck to write and the least useful one to believe. This is a founder's-eye walk down our own deck math, from a 134 billion dollar total market to a 6.7 billion dollar serviceable slice to a 3 percent obtainable target, and a defence of why only the last number, the one that converts into 180 million dollars of bookable revenue and a countable pile of 1,200 dollar seats, is worth planning a company around. The market-sizing literature has said for years that TAM is a ceiling and not a forecast; this is what that warning looks like when you apply it to a real raster-log software business.

Tversky versus Dice: Tuning the Precision-Recall Tradeoff in Thin-Curve Segmentation

We ran all five candidate losses for raster well-log digitisation through one controlled comparison and read them on the metric that actually ships: the error left on the digitised curve. Dice and Tversky reduce to the same overlap score until you use the one knob Dice does not have. Tversky's alpha-beta asymmetry lets you penalise false negatives directly, and that single recall tilt is what walks curve-1 goodness-of-fit from R-squared 0.81 to 0.9891 on the cleanest examples.

Why Energy Companies Keep Their Models On-Premises

Where a subsurface model runs looks like an infrastructure question and is answered as one, with GPU price lists and uptime tables. It is really a data-sovereignty question wearing an engineering costume. A national well-log archive is a hundred and thirty-six thousand scanned files that an operator will not let cross its firewall, and that single fact, not the difference between a 750-euro card and an 1800-euro one, is what pins serious subsurface models behind the wall. This post traces the reasoning from data gravity to serving design and is honest about what staying on-premises costs you in return.

Top-K Mode Subtraction: Isolating Dissolution Pores from Carbonate Background

Subtract the top-five intensity modes from a static high-resolution borehole image log patch and the dominant carbonate matrix collapses, leaving adaptive thresholding free to resolve individual dissolution vugs. This is a technique deep-dive on why a deterministic, mode-subtraction image-processing pipeline beats a learned segmentation mask for vug isolation — and how it runs at 15 s/m.

Digitization of raster logs — VeerNet, a U-Net + transformer hybrid

The full peer-reviewed treatment of VeerNet — the U-Net-inspired transformer-augmented architecture EarthScan uses for raster well-log digitisation. Covers the synthetic-curve generation pipeline, the Texas RRC real-data set, the loss-function ablation across Dice, Tversky, Lovász, Focal, and SCE, and the comparison with the Neuralog SCTR commercial baseline.

A Reader's Guide to the FORCE and Xeek Well-Log Competitions

A public well-log competition looks like a leaderboard, but the part worth reading is the scoring rule underneath it. The FORCE and Xeek 2020 event fixes one public set of 118 Norwegian Sea wells and 22 electrical-measurement feature columns, and it splits that set by well rather than by row. That single choice is the whole discipline: a validation depth is only genuinely unseen if its own neighbours are held out with it, which happens when you partition by well and quietly fails when you shuffle depth samples at random. This guide reads the competition not for who won but for what it standardises about measurement, and argues that the leakage-safe partition is exactly the habit a digitiser has to borrow before it can trust a number of its own. We use our archive scale as the yardstick, 136,771 scanned TIF files and 7,781 paired LAS files, to make the point that when your own data dwarfs any public set, the public set's value is not its size but its discipline. The instrument makes the trust gap visible: the score a leaky row split reports sits above the honest well-partitioned score, and that gap is invisible in the leaky number itself.

Adaptive Thresholding for Vugs: The Eight Parameters of a Classical-CV Detector

A technique deep-dive on the eight interpretable parameters that govern a Gaussian-modulated adaptive-threshold vug detector for carbonate borehole images — block size, the C constant, top-k modes, circularity, IoU, Laplacian and mean-based filters, and a centroid gate — and why that interpretability is exactly what makes it a better porosity-QC tool than a black box.

How Maps Get Turned Into Data: A Look at Cartographic Vectorization

A plain primer on the oldest raster-to-vector problem there is: turning a scanned map into geometry a computer can query. Long before anyone tried to lift a well-log curve off scanned paper, cartographers were already binarising sheets, tracing lines, reducing those lines to ordered points, and hanging attributes off the result. The claim of this note is that the well-log pipeline is not a new kind of task but one narrow instance of that much older cartographic problem, running the same four steps in the same order: binarise, trace, vectorise, attribute. We walk each step on the map first, where the intuition is easiest, then show the identical staircase on a scanned log, grounded in the real shape of one archive we worked with: 136,771 raster TIF sheets, 7,781 vector LAS strips, three-class per-pixel labelling, and curves reduced to 300 depth points written out as CSV or LAS. The point is not the log. It is that the log is a map of one very thin strip of the earth.

A Depth-Tolerance Confusion Matrix: Scoring Sinusoid Picks at 3 cm and 5 cm

Standard detection metrics — IoU, mAP, pixel accuracy — quietly break on borehole sinusoids. This is the case for a domain-correct alternative: a depth-tolerance confusion matrix that counts a fracture pick as a true positive when its depth lands within a physical band of the ground truth, scored at 3 cm and 5 cm against image logs from a fractured Middle East carbonate play.

Hough-Transform Auto-Scribbles: 10x Faster Unsupervised Segmentation Convergence

Kim-style unsupervised CNN segmentation converges slowly and over-fragments borehole image logs. Replacing hand-drawn scribbles with Hough-transform auto-scribbles — Canny edges fed through a probabilistic Hough line detector — seeds the spatial-continuity loss with the sinusoids that actually carry geology, cutting convergence from 500 iterations to 50 while producing cleaner boundaries than a human drew.

When More Data Hurts: Class Imbalance Explained for Practitioners

A primer on the one failure mode that a bigger dataset makes worse, not better: extreme class imbalance. When 97 percent of the pixels in a scanned well log are background, the majority class supplies almost all of the training signal, and adding more logs mostly adds more of what the model already predicts perfectly. We explain why a frame-averaged score lies, why the standard correction, a large positive-class weight, buys recall while precision collapses, and why the composite F1 is governed by whichever component is weaker. The mechanics are the field's, from the imbalance literature going back two decades; the worked numbers are from one of our own raster-log digitisation runs, a weighted binary cross-entropy at class weight 42, where curve recall reached 0.96 and 0.97 while the F1 on those same masks logged only 0.37 and 0.26. Because F1 is the harmonic mean, that gap pins the precision those masks must have carried at roughly 0.23 and 0.15, and it is the collapsed precision, not the soaring recall, that the composite score follows. This is a teaching note on the seesaw, not a product pitch.

Cubic Splines for Validating Predicted Curves Against Logs

A note on the least glamorous step in evaluating a curve-prediction model: getting the predicted curve and the reference log onto the same depth axis before you score anything. A model reads a raster log and emits a curve sampled at its own pixel spacing; the ground-truth LAS is sampled at another; the two rarely land on the same depths. Until they do, R-squared and mean absolute error are not just noisy, they are undefined, because you cannot subtract two series that do not share an index. The fix we used is ordinary and boring on purpose: cubic-spline interpolation of both series onto one fixed grid of 300 depth points, after which the numbers become comparable. On that common grid the best validation R-squared was 0.9891, the lowest MAE 0.0132, the lowest MSE 0.0004, with per-curve CSV MAE of 0.11 and 0.12 for curve 1 and curve 2 under Dice loss. This is a validation-side contract, not a training trick, and it is deliberately not a retelling of how VeerNet is trained or served.

Shipping a Frontend Demo Before the Model Is Done

A delivery note on a habit that felt backwards and turned out to be the discipline that held the schedule: we stood up a shared frontend, wired to a small set of real test logs, weeks before the curve-segmentation model behind VeerNet had converged. The demo did almost nothing at first, and that was the point. It gave every model checkpoint somewhere to land in front of a person, turned an invisible research effort into a weekly thing you could look at, and made the four-step upload-digitise-clean-download loop the unit of progress instead of a validation number nobody outside the team could feel. On a 16-week accelerated envelope run by 6 FTE, against a 32-week standard track at 4 FTE, that compression was not a nicety. It was how the model and the product stayed in the same conversation long enough to ship together. This is the product-and-model parallel track as a delivery discipline, not a shortcut, and specifically not a retelling of what VeerNet is.

Measuring a Digitiser With R-Squared, MAE, and MSE Against Ground Truth

A plain-English primer on the three numbers we put next to a recovered well-log curve once the depth axis is already aligned: the coefficient of determination, mean absolute error, and mean squared error. Each answers a different question. R-squared asks whether the recovered curve tracks the shape of the truth, MAE asks how large the typical depth miss is, and MSE asks whether a few rare large misses are hiding in the tail. On one recovered curve those three agreed the fit was good, R-squared 0.9891 with MAE 0.0132 and MSE 0.0004. On a harder curve they pulled apart hard: R-squared collapsed to 0.5461 while the typical miss only grew about tenfold and the squared-error summary blew up by roughly sixty. This note is about why the three disagree, what each is really measuring on a one-dimensional curve, and why a fair readout samples the curve evenly across the 300 interpolated depth points and reports all three rather than leaning on any one. It assumes the depth axis is already aligned, and it is deliberately not about mask overlap or grid construction.

Synthetic-to-Real Transfer in Industrial Inspection: Evidence Across Five Domains

A field survey that reads the published evidence on synthetic-to-real transfer across five industrial-inspection domains: remote-sensing tiles, robotic flight from CAD renders, manufacturing surface defects, scene and document text, and raster well-log curves. We ask one question of each domain, whether the reported success of training on synthetic data and deploying on real data tracks how faithfully the synthetic generator reproduced the target's actual degradation, and we find that it does. Domains whose generators model the real corruption directly, such as document text with its blur, warp, and compression noise, report the strongest transfer; domains whose generators match geometry but leave sensor and atmosphere unmodelled report the weakest. We anchor the argument on the one domain we can pin to measured numbers rather than qualitative field reports, a raster well-log digitiser where 15,000 synthetic multiclass instances transfer toward 136,771 real scanned logs at a peak intersection over union of 0.51 and a best single-curve goodness-of-fit of R-squared 0.9891. This is a reading of the public field with one worked internal anchor; it is deliberately not the VeerNet product story.

From Binary Log to Dataset: Patching a 690,000x360-Pixel Image Log for a Transformer

A data-engineering deep-dive on the step nobody writes papers about — slicing a ~1.5 GB high-resolution borehole image log into overlapping 800-pixel patches before a Detection Transformer can ingest it. The 800-pixel patch height is a dataset-design decision, not a model decision, and getting it wrong quietly caps your model's ceiling.

Raster to Vector in Cartography: A Survey of Map Digitization Methods

A survey of how cartography has converted scanned maps into vector geometry, from the parameter space line voting of the early 1960s through morphological thinning to the convolutional segmentation of the late 2010s, read as the closest published analog to pulling a curve off a scanned well log. We credit the cartographic prior art that defined the raster to vector problem and trace its five stage pipeline (scan, clean, segment, trace, resample) onto our own log digitisation work, where the shared output target is a curve resampled to 300 depth points and the hard stage is the mask to centreline geometry. We read the synthesis against our real three class raster log baseline, where line tracing accuracy on the thin curve masks peaks at an intersection over union of 0.51, and argue that the cartographic literature predicts both the shape of the pipeline and the location of its hardest step.

The Five Customer Segments That Need Subsurface Digitisation

A total addressable market tells you a category is large; it does not tell you who inside that category will actually buy first, and those are different questions. This is a demand-side breakdown of who needs raster well-log digitisation, read not as one undifferentiated 6.7 billion dollar software market but as five distinct buyer segments with five different reasons to care: explorers chasing a new play, private-equity teams pricing an acquisition, national oil companies sitting on the largest paper archives, independent operators with the thinnest budgets, and the new ESG and carbon-storage teams who need old logs to qualify a reservoir for injection. Each segment converts at a different speed, demands a different slice of the product, and contributes a different share of the obtainable revenue, and a fan-out instrument cross-references those shares against the three signed letters of intent and the 1,200 dollar per-seat price to argue which of the five a sales team should call on Monday.

How the Field Measures Overlap: IoU, Dice, and Boundary Metrics in the Literature

A survey of how the segmentation literature actually quantifies agreement between a predicted mask and ground truth, tracing the region-overlap family (intersection over union and the Dice coefficient) back to its origins, crediting the period-correct work that exposed its blind spots, and setting out the boundary-aware and per-class alternatives the field reaches for when thin structures are at stake. We read the synthesis against a real three-class raster-log baseline where one prediction earns an intersection over union of 0.94 on the background but only 0.26 and 0.21 on the two well-log curves, and an F1 of 0.97 against 0.37 and 0.32, to show concretely where region-overlap scores systematically mislead. This is a survey of the published measurement landscape and credits the prior art that defined it; the engagement numbers are ours and are used as a worked example, not as a new benchmark.

Loss Functions for Imbalanced Segmentation: A Quantitative Meta-Review

A literature-survey meta-review of the published loss landscape for imbalanced semantic segmentation, covering the Dice, Focal, Lovasz-Softmax, soft cross-entropy, and Tversky families. We synthesise what the field reports about each objective under heavy foreground-background skew, credit the prior art that defined them, and read the synthesis against a real three-class raster-log baseline where the background occupies about 97 percent of every frame. This is a survey of the published landscape, distinct from our own controlled Tversky-versus-Dice ablation, and it locates each family on the precision-recall and overlap-versus-per-pixel axes the literature has argued over since 2016.

Reading Loss Curves: What Adam and SGD Told Us Early

A primer on diagnosing a training run from the shape of the loss curve itself, before any scalar metric resolves. On our 2000-instance binary segmentation set the early Adam and SGD runs told us the convergence story in their curve morphology: where the loss plateaus, where it spikes, and where validation lifts away from training. We credit the optimisers and the early-stopping discipline to their original authors and claim only what is ours, which is the reading.

Tversky Loss When You Care More About Recall Than Precision

A practitioner's guide to one knob: the alpha-beta asymmetry in Tversky loss, and why a thin-curve digitiser deliberately turns it toward recall and accepts the precision it gives up in return. We hold the recall target at 0.97 and walk the operating point from the balanced Dice setting to the recall-tilted Tversky one, watching curve-1 error fall from MAE 0.0367 to 0.0277 and goodness-of-fit climb toward R-squared 0.9891. The loss is Salehi and colleagues', and the credit is theirs; what we offer is the reasoning for which way to turn the dial and how far.

VeerNet — a transformer-residual hybrid for raster well-log digitisation

VeerNet — published in MDPI Journal of Imaging — is the deep-learning architecture EarthScan built specifically for the raster-log digitisation problem: turning scanned paper well-logs into queryable digital curves. Hybrid CNN-residual encoder + transformer + upsampling decoder. F1 = 35%, IoU = 30% on a 10K-image benchmark.

Anchor-Free, Mask-Free: Adapting DETR Object Queries to Sinusoid Picking

How we repurposed a Detection Transformer's object queries from bounding boxes to sinusoid parameters — depth, dip, and azimuth — so a borehole-image model can pick fractures end-to-end with no anchors, no NMS, and no segmentation masks at all.

From Hough Transforms to U-Nets: how document-image AI learned to read curves

A field primer on six decades of line and curve extraction from scanned documents, from the 1962 Hough transform through morphology and FCN/U-Net segmentation to encoder-decoder networks with attention. It traces why that lineage is exactly what makes automated raster well-log digitisation tractable today.

How Detection Transformers Work — and Why Object Queries Replace Anchors

A first-principles primer on the Detection Transformer — how it throws out anchor boxes and non-maximum suppression and replaces them with a fixed set of learned object queries matched to ground truth by Hungarian assignment. That set-prediction framing is exactly why the same architecture that detects 80 COCO classes can be re-pointed at borehole sinusoids.

Benchmarks for Document Image Analysis: A Survey of Datasets and Their Blind Spots

Document-image benchmarks are graded on a leaderboard, and a leaderboard rewards whatever the test set contains. This survey reads the public document-analysis datasets not by what they include but by what they systematically leave out, and it argues that the omission is not random: the sets over-represent clean printed text and under-represent thin-line geometric content, so a model that tops the leaderboard can still fail on a scanned strip log. We credit the releases that defined the field, place them on a coverage matrix of content type against scan degradation, and show that the cell a scanned well-log occupies, thin geometric curves under heavy degradation, is empty. We use the log-digitisation task as the exposing case, with the real scale the public sets never reach as the yardstick: an archive of 136,771 scanned TIF files and 7,781 paired LAS files, and the 118 wells and 22 measurement columns of the Xeek/FORCE 2020 tutorial set. The central finding is that dataset representation, not model capacity, is the binding constraint for extreme document types, and that a benchmark's silence about a content class is invisible in its own score.

A Field Guide to Synthetic Image Generators in 2022

A working note on how we chose a generator for the training data behind a raster-log digitiser, and why a procedural renderer beat the generative options for this specific job. In 2022 the interesting synthetic-image families are three: adversarial, diffusion, and procedural. For photographs the first two are the obvious tools. For a structured technical drawing that a segmentation model has to label pixel by pixel, they carry a hidden bill: they produce an image but not the mask, so every synthetic sample owes a separate annotation pass before it is worth anything. A procedural renderer inverts that. Because it draws each curve from a known equation, it already knows the class of every pixel it emits, so the label falls out of the same call that draws the line. That is the whole argument, and it is why the pipeline behind VeerNet was a pycairo drawing loop rather than a generative model. We built 15,000 perfectly labelled multiclass logs (20,000 in the two-curve set) this way, spanning 3,200 to 12,800 pixels wide and 480 to 640 tall, from a 2,000-instance binary start.

Why Document Images Are Different From Photographs for Computer Vision

Most of the computer vision toolkit was built and benchmarked on natural photographs: three colour channels, a near-square crop, a subject that fills the frame. A scanned well log satisfies none of those. It is one grayscale channel, it can be twenty-seven times wider than it is tall, and roughly 97 percent of its pixels are empty background carrying no curve. This note treats the difference as a matter of pixel statistics rather than domain flavour, because the statistics are what decide the architecture. When the image is that wide and that empty, you cannot batch several of them together, so the batch size drops to one, and a batch of one breaks BatchNorm, which is why the network normalises with GroupNorm at a group size of 16 instead. The three curve outputs, background plus two curves, and the single input channel are the visible tip of a deeper mismatch with the assumptions ImageNet-era vision quietly bakes in. The argument here is not that logs are hard, it is that they are a different kind of image, and that naming the difference in numbers is what lets you choose the right defaults instead of inheriting the wrong ones.

What We Gave Up and Gained Switching From Classical CV to a U-Net

A head-to-head between a deterministic classical computer-vision pipeline (adaptive thresholding, Hough voting and edge-following, morphological thinning) and a learned U-Net for tracing a curve off a scanned well log. We frame the comparison around the three things that actually decided which one we shipped: the up-front cost to stand each one up, how brittle each is when the scan quality drops, and the places where the deterministic baseline still wins outright. We credit the public lineage each method comes from, report the real figures we measured on our own learned segmenter, and resist the reflex to declare a clean winner: the honest answer is that the two methods sit on opposite sides of a crossover, and knowing where that crossover falls is the whole skill.

Domain Randomization Since 2017: What Transferred and What Did Not

A field retrospective on domain randomization as a sim-to-real strategy, five years after the idea was named. We survey which randomization axes generalised across robotics, autonomous driving, and document and scientific imaging, and which stayed domain-specific, crediting the public literature from 2017 onward. We then ground the survey in our own procedural well-log generator, which renders synthetic raster logs across a 3,200 to 12,800 pixel width range and reads curves off real scans it never saw in training. The pattern that holds: randomize the nuisance, anchor the signal.

Region Proposal versus Per-Pixel Labeling: Instance and Semantic Segmentation Compared

A field survey of why per-pixel semantic labeling outperforms region-proposal instance segmentation when the targets are overlapping thin curves. Region-proposal methods in the Mask R-CNN lineage assign each object an axis-aligned box and a mask inside it; per-pixel methods in the FCN lineage label every pixel independently. We credit both lineages period-correctly, explain the geometric reason the box abstraction fails at curve crossings, and ground the comparison in our own raster-log setting of 2 constant curves per log and a 3-class target, reporting the sourced per-class IoU of background 0.94, curve 1 0.26 and curve 2 0.21.

Procedural Generation Engines for Vision Training: A Review of the Tooling

A review of the engines and pipelines a computer-vision team can use to manufacture labelled training imagery, organised by what each tool is actually good at rather than by the slogan of synthetic data. We separate the public tooling into recognisable families and credit each to its authors: photoreal game-engine renderers that turn a driving simulator into a labelled dataset, physically based and Blender-driven offline pipelines, structured domain-randomisation generators that abandon realism on purpose, procedural geometry-and-texture synthesis, and 2D compositing pipelines that paste cut-out objects into scenes. The organising question is the one that decides whether a generator earns its keep: does the task reward scene photorealism, or does it reward labels that are exact because the generator drew every pixel it labels? We then place our own synthetic well-log curve generator, built for the VeerNet raster-log digitiser, inside this family as a narrow-domain procedural generator that trades broad realism for total label fidelity, and report the only figures we measured: a 15,000-instance training set drawn at 3,200 to 12,800 pixels wide. The contribution is a map of the tooling plus one honest worked instance at its label-fidelity corner.

Public Benchmarks and Datasets for Document Image Segmentation

When we set out to segment scanned raster well logs, the natural first move was to reach for an existing public benchmark. This is a catalogue of the document-image segmentation datasets that were available to us at the time, with credit to the groups that built them: PubLayNet and DocBank for born-digital page layout, the PRImA layout-analysis set and DIVA-HisDB for scanned and historical pages, and the cBAD baseline-detection set from the READ project. Each is a strong release for the page-shaped documents it targets. None of them covers the image geometry a well-log scan takes, which is a strip thousands of pixels wide and only a few hundred tall, so we map that blind spot precisely and explain why it forced us to synthesize our own training corpus instead.

Machine-Learned Log Prediction: A Survey of Synthetic Sonic and Density Estimators

A field survey of the published petrophysics-ML literature that predicts a missing sonic or density curve from the rest of the wireline suite. We credit the methods that made synthetic-log prediction a standard tool, from the open SEG facies contest baseline through feed-forward and recurrent estimators of compressional and shear transit time, and we read their reported accuracies off a common scoreboard. Much of this work trains and tests on the same open corpus: the FORCE and Xeek tutorial slice of 118 Norwegian Sea wells with 22 measurement columns, with the density-family curves of Track 3 (NPHI and RHOB) as canonical targets. The survey's organising claim is that all of these estimators assume vector curves as input, and that recovering those vectors from scanned raster logs is the upstream digitisation step that feeds them, the problem our own VeerNet system was built to solve.

Augmenting at Inference: Test-Time Augmentation for Noisy Field Scans

Training-time augmentation shapes what a model learns; test-time augmentation shapes how a single prediction is formed. This piece is about the second lever, and why we reached for it on the inputs our synthetic pipeline never fully covered: the messy field photographs of paper logs, captured under uneven light, off-square, faded. The recipe is cheap and old. Pass the same scan through the fixed network several times under label-preserving transforms (a horizontal flip, a small pixel shift), un-transform each output mask back into the original frame, and average the per-pixel votes. We credit the public lineage the idea comes from, report what it actually moved on our own multiclass curve error (off a Dice single-pass baseline toward the recall-favoured Tversky bracket), and are honest about the curve it helped and the curve it did not.

Vugs Explained: Dissolution Pores, Secondary Porosity, and Why They Matter

A vug is a dissolution pore that reads as a low-resistivity dark blob on a high-resolution borehole image log. This explainer unpacks what vugs are, why secondary porosity makes them a first-order reservoir-quality signal in carbonates, and how turning each blob into a number — count, area, and circularity per 10 cm — becomes the supervision behind an automated vug detector.

Why We Chose Multiclass Over Binary Segmentation

A note on a target-formulation decision we made early in the curve-segmentation work behind VeerNet, and why it was a decision about label shape rather than about loss or class weight. Faced with two curves to pull off a scanned well log, the obvious first move is a stack of independent binary masks, one sigmoid per curve. We tried that. With a weighted binary cross-entropy and the positive-class weight pushed to 42, recall on the masks climbed to 0.96 and 0.97, but the per-mask F1 refused to cross 0.55, and two of the three masks sat at 0.37 and 0.26. The reason is structural: independent masks are free to claim the same pixels, so precision never recovers no matter how hard you weight. Reformulating the same task as a single three-class softmax pass, background plus curve one plus curve two, changes the shape of the prediction to a mutually exclusive assignment, which is what actually separates the two curves. This is deliberately not the class-imbalance-weighting story; the weight is held fixed and the thing that moves is the target.

What a Borehole Image Log Is — and What Those Sinusoids Tell You

A first-principles explainer of how a high-resolution borehole image log unrolls the borehole wall into a flat image, why every planar feature crosses it as a sinusoid, and how that sinusoid's amplitude and phase encode dip and azimuth — the geometry every borehole-image AI model has to respect.

Automated borehole-image-log correlation via unsupervised CNN segmentation

High-resolution borehole image logs reveal fractures and breakouts that conventional logs cannot — but annotating them is laborious and inconsistent. This work shows that unsupervised CNN segmentation (Kim et al., 2020) detects bedding planes and fracture sinusoids without any labelled training data. Presented at EAGE Workshop on Borehole Geology in Asia Pacific.

The 1-Pixel = 3 cm Rule: The Resolution Floor Every Depth Metric Hits

A borehole image log is a raster, and on the binary wireline log files we worked with one pixel of depth is about 3 cm. That single fact puts a ±3 cm error floor under every depth metric before a model runs a forward pass — which is why a 2 cm scoring tolerance is unfair to the network and a 3 cm tolerance is the honest place to start reading any depth accuracy claim.

Building a Synthetic Data Factory When Labels Do Not Exist

A working note on treating a synthetic-data generator as a factory line rather than a one-off script. When no labelled corpus of scanned well logs exists to learn from, the generator is not a preprocessing step you run once; it is the production tool the whole model depends on, and it earns its keep only if it has throughput, a build order, stop criteria, and versioned output. We describe the render-and-emit-mask loop that is the single machine at the centre of it, and the order we ran it in: a first binary batch of 2,000 instances to shape the loop and prove the mask, a 20,000-log two-curve multiclass batch in December 2021, and a curated 15,000-curve corpus as the shipped version. Each stage reused the emitter written for the one below it, each closed on an explicit stop count, and each output was an image plus a pixel-perfect mask at 3,200 to 12,800 pixels wide. This is about the line and its cadence, not about why the labels were missing or how the randomisation was designed.

Serverless Inference on a Budget: Running Vision Models in AWS Lambda

A cost note on serving a raster-log vision model the cheap way. For a digitisation workload that arrives in short, unpredictable bursts and sits idle the rest of the month, the serving question is not which framework is fastest but which cost geometry you are paying. A permanently-on GPU box charges the same 750 or 1800 EUR every month whether it clears a thousand scans or none, so at low, spiky volume most of that rent buys idle time. An EFS-backed Lambda inverts the shape: it costs nothing at rest and charges per invocation, with a cold-start penalty each time a container has to reload the multi-hundred-MB grayscale model from the shared file system. The two lines cross at a volume where the fixed rent is finally repaid by enough runs. This note is about where that crossover sits, why the cold-start share moves it, and why for our traffic profile the pay-per-call line stayed under the box for the whole plausible range. It is deliberately not the VeerNet deployment case study; that one is about the mechanics of getting the model into Lambda, this one is only about the money.

Why Image Logs Have Holes: NaNs, the -9999 Code, and Inter-Pad Gaps

A field-grounded explainer for data scientists meeting high-resolution borehole image logs for the first time: the tool only touches ~80% of the wall, the rest arrives as the sentinel -9999, and those inter-pad gaps become NaNs your model must impute before it can learn anything. Understanding the hole is the prerequisite to filling it — and to choosing KNN over a GAN.

What Data-Centric AI Actually Means Outside the Hype

The data-centric-AI movement says the next gains in real-world performance come from improving the dataset, not the architecture. Crediting that argument and the people who made it, we add one concrete data point from our own raster-log work: with the backbone frozen, swapping a 2,000-instance baseline for 15,000 curated synthetic instances moved the task more than any architecture change did. The lever was the dataset.

A Plain Tour of Segmentation Architectures, From FCN to Modern U-Nets

An accessible field tour of the segmentation-architecture family tree, from the 2015 fully convolutional network through SegNet and U-Net to the attention-gated U-Nets of 2018. It follows one thread, how each design carries fine detail forward and climbs back to full resolution, and credits Long, Ronneberger and their successors period-correctly along the way.

The Public Well-Log Benchmark Landscape: What FORCE, Xeek, and Volve Standardized

Petrophysical machine learning got its shared yardsticks from a small set of open releases: Equinor's Volve field data, the FORCE 2020 lithology competition, and the Xeek platform that hosted it. We credit those releases for giving the field common, depth-aligned, vector-LAS benchmarks, then map where our TXRRC-derived raster archive sits relative to them. It is a complementary, raster-native corpus of 136,771 scanned TIF files and 7,781 LAS files: larger in raw count, weaker in labels, and one data point among the open benchmarks rather than a replacement for them.

A Survey of Semantic Segmentation Backbones for Scientific Imagery

A field survey of the encoder backbones that semantic-segmentation work reached for when the input was scientific (non-photographic) imagery rather than natural photographs. We credit the public lineage period-correctly, from deep plain stacks through very-deep residual stacks, dense connectivity, and dilated context, to the symmetric residual encoder-decoder with skips, and we read each family against two demands that scientific images make: appetite for labelled data and fidelity to thin, one-pixel-wide structure. The organising observation is that the backbones the wider field leaned on were tuned on photographic corpora at internet scale, a regime that scientific imagery rarely occupies. We situate our own residual encoder-decoder configuration, 5 encoder residual blocks, 128 feature-depth channels, 2 attention layers, and 1 grayscale input channel, on that surveyed map, and argue it is a sensible position rather than a new branch of the tree.

The Data-Centric Turn in Computer Vision: A Survey of Dataset-First Methodology

A research-paper survey of the data-centric turn in computer vision, the movement that treats iterating on the dataset, rather than searching the space of architectures, as the highest-leverage way to move a real-world model. We separate the movement's three threads period-correctly: the explicit reframing and its frozen-model competition, the field studies that documented how undervalued data work compounds into downstream failure, and the audits that found the benchmarks themselves carry enough label noise to reorder model rankings. We then map where a synthetic-data-first segmentation program sits in that literature, using one piece of our own evidence: with a single fixed encoder-decoder held constant (128 feature channels, 5 encoder and 5 decoder stages, 2 attention layers), scaling a generated training set from 2,000 to 15,000 instances was what carried the attained fit to an R-squared of 0.9891. The dataset was the operative variable, and the synthetic-first program is a recognisable position within the surveyed methodology rather than a departure from it.

A Tour of Where Subsurface Data Actually Lives

A field tour of the public and national subsurface archives that anyone can actually reach: Equinor's Volve field release, the FORCE 2020 competition that Xeek hosted and scored, and the vast scanned-log trove of the Texas regulator. It credits each for what it opened, then looks at the physical shape the data arrives in, and explains why so much subsurface value still sits trapped in paper rather than in machine-readable curves.

Borehole Image Logs 101: What Sinusoids, Dip and Azimuth Actually Mean

An onboarding primer for the engineer, not the geologist. A high-resolution borehole image log is a sensor reading you train models on — so we treat it as a tensor from the start: how 192 electrodes become an azimuth-by-depth array, why every planar feature unrolls into a sinusoid, and how the fitting form A·sin(0.0175·x + φ) + offset turns directly into the (depth, dip, azimuth) label vector your detection pipeline regresses.

Semantic Segmentation for Curve Tracing: A Plain-English Primer

A ground-level explainer of what semantic segmentation actually does when it reads a scanned well log, aimed at anyone who has heard the phrase and wants the mechanism rather than the marketing. The short version is that the network never traces a line. It looks at every pixel and answers one question about that pixel alone: which of a small set of classes does this belong to. On our raster-log task that set has three members, background and two curves, and the whole input is a single grayscale channel. That reframing, from following an edge to labelling a pixel, is what lets the model keep two log curves apart where they cross, which is precisely the place an edge-follower gets lost. It also turns the awkward fact that a log is almost all background, roughly 97 percent of pixels, with the two thin curves together under 2 percent, into an explicit and handleable property of three classes rather than a nuisance. This is a primer on that idea and why it fits curve tracing, not a description of any one product pipeline.

EarthAdaptNet on F3 + Penobscot: a domain-adaptation case study

Companion to the EarthAdaptNet architecture paper — this post applies EAN to two real industry seismic datasets (F3 block, Netherlands; Penobscot, Canada) and introduces the deep domain-adaptation (DDA) variant for the unlabelled-target case. Lays the groundwork for the IEEE TGRS 2022 paper.

Oil & gas needs MLOps, not just ML

Oil and gas generates terabytes of operational data daily and spends $3.3 trillion in annual revenue — yet ML projects in the industry routinely die between training and production. The bottleneck isn't the models. It's MLOps. Originally published on HackerNoon.

Deep learning in geoscience and subsurface: a practitioner's guide

A practitioner-oriented walkthrough of where deep learning earns its keep in subsurface workflows — seismic imaging, reservoir characterisation, fault detection — and where the literature still over-promises. Webinar recap with the key papers and code links.

EarthAdaptNet: a domain-adaptive encoder-decoder for seismic imaging

The architectural detail behind EarthAdaptNet (EAN) — the encoder-decoder network EarthScan applies to semantic segmentation of seismic images. Companion to the geothermal case-study post; this one focuses on the building blocks (Residual Blocks, Transposed Residual Blocks, U-Net-inspired skip connections) and the per-class accuracies on the Roosevelt benchmark.

AI for geothermal: applying seismic-facies segmentation to a clean-energy reservoir

How the same deep-learning toolkit oil & gas operators have been using to interpret seismic data can be redirected at a clean-energy problem: locating geothermal reservoirs. Case study from the Roosevelt Hot Springs Geothermal Area, Utah, using EarthScan's EarthAdaptNet encoder-decoder architecture.

Data-centric AI development: from Big Data to Good Data

Andrew Ng's reframing — that the next 90% of AI's value will come from improving the data, not the model — changes how production teams build pipelines. A webinar recap covering data ingestion, the data pipeline, MLOps, and why AugMix is one of the most underrated augmentation methods.

Case studies

See how operators put EarthScan to work

Anonymised deployments — the challenge, the approach, and the numbers that changed.

Explore case studies →
EarthScan

Contact us

Tell us about your data — we'll come back within one working day

Three short steps. We use your answers to route to the right person on our side and prepare a relevant first reply.

  1. 1
  2. 2
  3. 3

Use the email your team uses for work — it bypasses spam filters and lets us route to the right person on our side.

Prefer a calendar slot? Book a 20-minute call directly →

EarthScan
Continuous AI for explorers

info@earthscan.io

Follow us on

Go to Top

© 2026 Copyright. Earthscan