11. Learning-Enhanced Inversion

Insertion points for learning, calibration matrices, virtual strains & GP completion, synthetic training data, PINNs and their failure modes, neural operators & amortized inversion, GNN–iFEM hybrids, out-of-distribution honesty, tactile skins

Contents

1. Why Learn Anything? Six Insertion Points 2. The Simplest Learned Map: Calibration Matrices, then Networks 3. Virtual Strains: GP Completion and Smuggled Priors 4. FEM as a Training-Data Factory — and the Sim-to-Real Gap 5. Per-Instance Physics: PINNs for Shape Sensing and Inverse Elasticity 6. When PINNs Fail — What a Low Loss Cannot Tell You 7. Amortized Inversion: Neural Operators 8. Structure and Hybrids: Shallow Decoders, GNNs, Residual Correction 9. Head to Head: iFEM versus Learned Shape Sensing 10. Generalization, Leakage, and Out-of-Distribution Honesty 11. Case Study: the Tactile Skin, Learned-Map Angle 12. A Practitioner's Decision Procedure Interactive: Virtual-Sensor & OOD Laboratory Interactive: The Physics-Loss Dial Interactive: Choosing the Insertion Point Flashcards

1. Why Learn Anything? Six Insertion Points

Recall what Modules 4–6 built. Discrete strain measurements enter a weighted least-squares functional over inverse elements; minimization yields a linear system whose matrix depends only on the mesh, the sensor layout, and the weights — not on the loads and not on the measured values (Tessler & Spangler 2005):

\Phi(\mathbf{u}) \;=\; \sum_{e=1}^{n_{el}} w_e \left\lVert \boldsymbol{\varepsilon}^{e}(\mathbf{u}) - \boldsymbol{\varepsilon}^{e}_{\text{meas}} \right\rVert^2 \;\longrightarrow\; \mathbf{K}\,\mathbf{u} = \mathbf{f}(\boldsymbol{\varepsilon}_{\text{meas}})

\mathbf{u} \;=\; \mathbf{K}^{-1}\mathbf{f}(\boldsymbol{\varepsilon}_{\text{meas}}), \qquad \mathbf{f}(\boldsymbol{\varepsilon}_{\text{meas}}) = \mathbf{B}\,\boldsymbol{\varepsilon}_{\text{meas}}, \qquad \mathbf{K} \text{ factorized once offline, independent of loads}

($\mathbf{K}$ is the assembled least-squares matrix of Module 4 — geometry and weights, not stiffness — and $\mathbf{B}$ is the linear operator that assembles the right-hand side from the measured strains. Note the standing qualifier behind that inverse: strain data alone leaves the rigid-body pose unobservable, so $\mathbf{K}$ is singular until the essential constraints that pin the pose are applied. Every $\mathbf{K}^{-1}$ on this page means the constrained matrix.) This module asks where, in that pipeline, a trained component earns its place. The question is sharper than "iFEM or machine learning?", and across the work surveyed here the useful organizing question has been stage by stage.

Core Problem

In the guide's observation model $y = \mathcal{H}(u, p, f, X_0) + b + \eta$, a learned component is a map fitted from data that replaces or augments some stage between the measurements $y$ and the reconstructed field. For each candidate insertion: what does the component learn from, what prior does it smuggle into the inversion, what does it cost at inference, and how does it behave on inputs outside its training distribution? The methods here cut across all four inverse families of this guide — the demonstrations below are anchored in shape sensing, but nothing in the taxonomy is specific to it.

	In this module
Measured	Sparse strains (gauges, FBGs) or camera-tracked displacement fields, noisy
Unknown	The full-field response $\mathbf{u}$ — plus, for any offline-trained component, the parameters $\theta$ fitted before deployment
Assumed known	Method-dependent, and the differences are the whole taxonomy. Physics routes: geometry, kinematic model, sensor layout. Offline-trained components add the training distribution: which load cases, which specimen, which noise level the data covered. The calibration matrix needs none of the model at inference (Section 2); a per-instance PINN needs no training distribution at all, but does need the PDE, a constitutive model, the boundary conditions, pose anchors and a collocation sample (Section 5)
Unobservable	Rigid-body pose (Module 4), plus — for offline-trained maps — anything outside the support of the training distribution: the map is simply not pinned down there

Three Structural Facts Before Any Learning

Fact 1: linear iFEM inference is already real-time. The system matrix is assembled and factorized once; each new strain frame costs a right-hand-side assembly plus two triangular solves against the stored factors — or one matrix–vector product if you went further and precomputed the dense transfer map $\mathbf{K}^{-1}\mathbf{B}$. So "neural networks because iFEM is slow" is a weak motivation for linear problems — a paper (or a page) that leads with speed has picked the wrong fight.

Fact 2: iFEM is load-agnostic. No load model appears in the functional, so the reconstruction generalizes to any load case within its modeling assumptions: linearized kinematics and the inverse element's chosen beam/shell model, known geometry and sensor map. (Note what is not on that list: a constitutive law. Displacement reconstruction is material-free; elasticity only enters later, at stress recovery.) An offline-trained, amortized measurement-to-field map has no such property — it silently encodes the load distribution it was fitted on. (A per-instance fit, PINN included, has parameters but no deployment-load distribution; the property being contrasted here is amortization, not the presence of fitted parameters.) Claiming either method has the other's property is a standard error in both directions.

Fact 3: iFEM's genuine weak points are where learning enters. It needs a mesh and a kinematic model. It needs strain data covering the inverse elements — elements without sensors get very small weights against a target of zero — a weak zero-strain prior, not an absence of data. It can actually improve conditioning by supplying rank in directions no sensor sees; what it costs is bias, pulling dark regions toward zero section strain (Module 6). Learned completion swaps that zero for a better-informed guess, but the guess is still correlated pseudo-data rather than measurement. It inherits small-strain, model-form assumptions and struggles with geometric nonlinearity (large deflections; soft materials driven out of the small-strain regime), with a wrong kinematic model or geometry, with localized strain gradients too sharp for the sensor set and the inverse-element mesh to resolve, and with unconventional sensor modalities (cameras, resistive skins). Be equally precise about what does not belong on that list: because displacement reconstruction is material-free, neither linear viscoelasticity nor a stiffness-changing damage state by itself invalidates the instantaneous strain-to-shape compatibility the solve rests on — they change the strain field the sensors see, and they matter for stress recovery, which is a different claim. Those four gaps — sparsity, nonlinearity, model error, modality — are the honest motivations.

Trap — the speed motivation

Precomputed linear iFEM costs one mat-vec per frame; a trained feed-forward network costs one forward pass per frame. They are in the same speed class. The methods in this module are justified by sensor sparsity, nonlinearity, unknown boundary conditions or damage, and non-strain modalities — never by inference speed against a factorized linear solve. (Amortized speed does become the argument when the per-instance alternative is an iterative optimization — Section 7.)

One terminology anchor before the taxonomy: "iFEM" on this page means Tessler–Spangler least-squares shape sensing — a one-shot linear reconstruction that needs no gradients. Two variants travel under that name and the difference matters below: the classical Tessler–Spangler functional fits strain misfit only, while generalized formulations add a displacement-misfit term and can therefore ingest discrete displacement data as well (de Mooij & Martinez 2024 score both sensor types, and combinations of them). Unqualified "iFEM" below means the strain-input form; where the displacement variant is in play it is named. The gradient-based, PDE-constrained inversion machinery (adjoints, differentiable FEM) is Module 10, and this module leans on it as a prerequisite: several methods below need gradients through a forward model, and Module 10 is where those gradients come from.

The Six Insertion Points

Organize every "iFEM × learning" paper by where the trained component sits:

Sensor completion / virtual strains — estimate strains at unsensed locations before a standard iFEM solve; physics-based (Oboe, Sbarufatti & Giglio 2022), Gaussian-process (Poloni et al. 2023), or neural. Section 3.
Learned priors and regularizers — the completion's kernel or training set is a prior on the strain field; more broadly, any data-fitted smoothness or subspace assumption inserted into the inversion. Section 3.
Surrogates — a trained stand-in for the forward model, used inside design loops and iterative inversion where thousands of FEM evaluations are too expensive. Sections 3 and 7.
Residual correction / hybrid refinement — a physics solve stays in the loop and a network refines or enriches the reconstruction after it. Section 8. (The published GNN + iFEM hybrid of Hong et al. (2026) keeps a physics solve in the loop, but whether its learned stage sits upstream of the solve — strain completion, point 1 — or downstream of it as refinement is a real distinction that the title does not settle. This page therefore files it under neither; see Section 8.)
Placement optimization — the design-time loop that chooses sensor sites through repeated iFEM evaluation (Ghasemzadeh & Kefal 2022); canonical treatment in Module 6, with the learning-specific angle in Section 3.
Amortized inversion — learn the measurement-to-field map end to end: the linear calibration matrix (de Mooij & Martinez 2024), deep regression networks, and neural operators (Molinaro et al. 2023). Its physics-first counterpart, the per-instance PINN (Qiu, Arunachala & Linder 2023), solves each case by optimization instead — the two are distinct alternatives, not variants of one idea. Sections 2, 5–7.

Six insertion points for learning in the shape-sensing pipeline. Physics blocks (blue) can be kept, augmented, or bypassed; every orange block carries fitted parameters $\theta$, and every offline-trained one — completion, refinement, surrogate, end-to-end regression — carries a training distribution with them. The per-instance PINN is the exception: it fits $\theta$ to the case in front of it, so it has parameters without a deployment-load distribution. Across the papers surveyed here, the arc runs from the bypass arrow (replace everything) toward hybrids that keep a physics layer in the loop.

The arc matters — stated, as it must be, over the work surveyed on this page rather than over the field: among the 2019–2023 papers collected here, "replace iFEM with a network" demonstrations predominate; the 2024–2026 ones more often keep a physics layer in the loop and let learned components fill specific gaps — completion front-ends feeding standard solves, and GNNs composed with iFEM rather than replacing it. A couple of dozen references chosen to populate a taxonomy cannot establish a field-wide trend, and nothing below depends on one. The pre-ML comparison culture of the field (Gherlone, Cerracchio & Mattone 2018 is the standard review and experimental comparison of shape-sensing families) set the template this module follows: methods are compared on stated assumptions and measured error, not on novelty.

2. The Simplest Learned Map: Calibration Matrices, then Networks

Before deep learning, there was a data-driven shape sensor of complete transparency: the calibration-matrix (CM) method, studied head-to-head against iFEM by de Mooij & Martinez (2024). Apply $m$ known load cases to the structure — physically or in simulation. Record the sensor vectors as columns of $\mathbf{E}_{\text{train}} \in \mathbb{R}^{n_s \times m}$ and the displacement responses as columns of $\mathbf{U}_{\text{train}} \in \mathbb{R}^{n_{dof} \times m}$. Reconstruct any new state as a linear combination of the known cases:

Calibration-Matrix Method

$$\mathbf{u} \;=\; \mathbf{C}\,\boldsymbol{\varepsilon}, \qquad \mathbf{C} \;=\; \mathbf{U}_{\text{train}}\,\mathbf{E}_{\text{train}}^{+}$$ with $\mathbf{E}^{+}$ the Moore–Penrose pseudoinverse: $\mathbf{C}$ is the least-squares-optimal linear map from sensor readings to displacement DOFs over the training set. No mesh, no kinematic model, no material constants at inference — only recorded load cases. Read that qualifier strictly: if the calibration cases are simulated rather than measured, geometry, mesh, material and BCs were all required to produce them, and $\mathbf{C}$ inherits that FE model exactly as Section 4 describes. Only the inference step is model-free.

Why It Is Exact In-Span — and Only In-Span

For a linear elastic structure, both $\mathbf{u}$ and $\boldsymbol{\varepsilon}$ depend linearly on the applied load $\mathbf{p}$. If the test load lies in the span of the training loads, it is a linear combination of them; by superposition, the same linear combination of training responses is the test response, and the CM reproduces it exactly in the noise-free limit:

\text{test load } \mathbf{p} \in \operatorname{span}\{\mathbf{p}_1,\dots,\mathbf{p}_m\} \;\Longrightarrow\; \mathbf{C}\boldsymbol{\varepsilon}(\mathbf{p}) = \mathbf{u}(\mathbf{p}) \qquad \text{(linear, noise-free, } \operatorname{rank}\mathbf{E}_{\text{train}} = m \text{)}

That is a clean linear-algebra guarantee, and it delimits the method just as cleanly: outside the span there is no guarantee at all. Two practical consequences. Rank: you need enough independent load cases to span the deployment loads. Conditioning: near-collinear training cases — loads that produce almost the same strain pattern — make small singular values of $\mathbf{E}_{\text{train}}$, and the pseudoinverse amplifies noise in those directions by their reciprocals. Note what that does and does not bound: the reciprocals govern the fitted coefficients; the number you deploy is the gain of the composite map, $\lVert\mathbf{C}\rVert = \lVert\mathbf{U}_{\text{train}}\mathbf{E}_{\text{train}}^{+}\rVert \le \lVert\mathbf{U}_{\text{train}}\rVert / \sigma_{\min}(\mathbf{E}_{\text{train}})$ — the same distinction Section 9 draws for iFEM's $\lVert\mathbf{K}^{-1}\mathbf{B}\rVert$. The Module 3 SVD story applies verbatim, with the training matrix in the role of the operator.

Trap — in-span exactness is superposition, not learning

A linear demo in which a CM (or a linear regression network) reconstructs unseen load cases "perfectly" has demonstrated linearity: the unseen cases sat in the span of the training cases, and superposition did the rest. It says nothing about generalization to nonlinear regimes or out-of-span loads. Any claimed generalization result on a linear structure must first rule out this explanation.

From $\mathbf{C}$ to $f_\theta$

The nonlinear generalization replaces the matrix by a network $f_\theta$ — typically an MLP for gauge-vector inputs — trained by minimizing mean-squared displacement error over a dataset of (strain, displacement) pairs, with per-channel normalization of strain inputs and displacement targets as standard practice:

\min_{\theta} \; \frac{1}{N}\sum_{i=1}^{N} \left\lVert f_{\theta}(\boldsymbol{\varepsilon}_i) - \mathbf{u}_i \right\rVert^2

The three families now sit on a spectrum of prior knowledge:

Method	Model?	Training data?	What the map encodes
iFEM	Mesh + kinematics	None	Compatibility; load-agnostic within model assumptions
Calibration matrix	None at inference (an FE model if the cases are simulated)	$m$ measured (or simulated) load cases	The span of the training loads, exactly
NN on synthetic FEM data	Distilled into data	Thousands of FEM solves	The FEM model evaluated over the sampled load distribution (Section 4)

Terminology precision: the CM method is linear least-squares regression — data-driven, yes; deep learning, no. Keeping "data-driven", "learned", and "deep" distinct is not pedantry: the failure modes (span limits, conditioning) are classical linear algebra, and dressing the method in ML vocabulary hides where the guarantees come from.

The Comparison Study

De Mooij & Martinez (2024) compared CM against iFEM on literature benchmark problems plus a twisted, tapered blade with a NACA 6412 cross-section, meshed with quadratic reduced-integration hexahedral solid elements — discrete displacement sensors, strain sensors, or both; surface-mounted and volume-distributed sensor sets; linear elastic material throughout; accuracy (displacement, strain, and load reconstruction) and computational efficiency both scored. Their headline result: on their test cases the CM method achieved average displacement and strain errors below 0.01%, while their iFEM implementation averaged 21% displacement and 99% strain error, and CM repeat solutions ran roughly 100× faster after set-up.

Key insight — read the conditions, not just the numbers

The CM advantage is conditional on training load cases that span the deployment loads — exactly the information iFEM never asks for. The comparison's real lesson is a trade: known load cases versus a trustworthy model. Which method wins is decided by which of those two you can actually supply, not by the error table of any single study. Section 9 builds the full comparison on this footing.

3. Virtual Strains: GP Completion and Smuggled Priors

The first insertion point leaves the solver untouched and fixes iFEM's most common practical ailment: not enough sensors. Recall the weighting mechanism from Modules 4 and 6 — inverse elements without measured strains receive weights orders of magnitude below unity:

w_e \;=\; \begin{cases} 1 & \text{element } e \text{ instrumented} \\ w_{\min} \ll 1 & \text{element } e \text{ without sensors} \end{cases}

Sparse coverage degrades accuracy and biases the unsensed regions toward zero section strain; the small weights still supply rank in directions no sensor sees, so the conditioning of $\mathbf{K}$ is not necessarily the casualty (Fact 3 above; Module 6). The completion strategy densifies the data instead of the hardware: estimate strains at unsensed points first, then run the standard iFEM solve with full coverage. Oboe, Sbarufatti & Giglio (2022) developed the physics-based version — a pre-extrapolation that uses model information to construct the sparse-to-dense map; the full machinery, and its ordering after raw observability analysis, is Module 6's business. Here we care about the learned versions and what they change epistemically.

Gaussian-Process Completion: Uncertainty Included

Poloni, Oboe, Sbarufatti & Giglio (2023) take the step toward a stochastic inverse finite element method: replace the deterministic extrapolation by Gaussian-process regression on the measured strains. A zero-mean GP prior with kernel $k(\mathbf{x}, \mathbf{x}')$ — a kernel alone does not define a GP, and the mean function is the half people forget to state — conditioned on the $n_s$ measurements returns, at every unsensed point, both a mean and a variance:

\hat{\varepsilon}(\mathbf{x}) \;=\; \mathbf{k}_{*}^{\mathsf{T}} \big( \mathbf{K}_{ss} + \sigma_n^2 \mathbf{I} \big)^{-1} \boldsymbol{\varepsilon}_{\text{meas}}, \qquad \operatorname{Var}\big[\varepsilon(\mathbf{x}) \mid \boldsymbol{\varepsilon}_{\text{meas}}\big] \;=\; k(\mathbf{x},\mathbf{x}) - \mathbf{k}_{*}^{\mathsf{T}} \big( \mathbf{K}_{ss} + \sigma_n^2 \mathbf{I} \big)^{-1} \mathbf{k}_{*}

The first display is the zero-mean form; with a nonzero prior mean $m(\mathbf{x})$ it reads $\hat{\varepsilon}(\mathbf{x}) = m(\mathbf{x}) + \mathbf{k}_{*}^{\mathsf{T}}(\mathbf{K}_{ss} + \sigma_n^2\mathbf{I})^{-1}(\boldsymbol{\varepsilon}_{\text{meas}} - \mathbf{m}_s)$, and the posterior variance is unchanged. Mind also which quantity carries the variance: $\hat{\varepsilon}(\mathbf{x})$ is the posterior mean, a fixed number once the measurements are in hand. The second display is the posterior variance of the latent strain field given those measurements — that is the object the band on the plot draws.

The mean feeds the iFEM solve as before; the variance is the new capability — the completion now says where it does not know, which no deterministic extrapolation and no plain regression network does. The kernel choice (length-scale, smoothness class) is an explicit, inspectable prior on the strain field. That the sparse-measurement regime is the rule rather than the exception in deployment is illustrated at scale by Huang et al. (2024), who monitor thermal deformation of large composite honeycomb spaceborne antennas from limited strain measurements — structures where instrumenting densely is simply not an option.

Trap — the completion smuggles a prior into a "material-free" method

Completed strains are correlated pseudo-data, not new independent measurements: every virtual strain is a function of the same $n_s$ real readings, and the GP posterior makes the correlation explicit. The downstream iFEM solve remains material-free — but the pipeline as a whole now contains a learned (or chosen) prior: the kernel's smoothness assumption, or the training set of a neural completion. If the true strain field violates that prior — a sharp gradient from damage, a load case unlike the training set — the completion confidently feeds the solver wrong data, and the solver has no way to know. iFEM's "no training data, no load model" property describes the solver, not the system you deployed.

The Placement Loop, and What "Learning" Honestly Means There

Insertion point 5 is design-time. Sensor placement is a discrete optimization — choose $n_s$ sites from a candidate set to minimize expected reconstruction error over anticipated load cases:

\min_{\mathcal{S} \subset \mathcal{C},\; |\mathcal{S}| = n_s} \;\; \mathbb{E}_{\mathbf{p} \sim P_{\text{loads}}} \left[ \left\lVert \mathbf{u}_{\text{iFEM}}(\mathcal{S}; \mathbf{p}) - \mathbf{u}_{\text{ref}}(\mathbf{p}) \right\rVert^2 \right]

The combinatorial search is metaheuristic territory — Ghasemzadeh & Kefal (2022) coupled a genetic algorithm to iFEM for plate and shell structures; Module 6 owns that machinery. Two points belong here. First, terminology: GA and PSO are evolutionary metaheuristics, not statistical learning — nothing is trained, nothing generalizes; calling placement optimization "iFEM × ML" is only honest because of the second point: the inner loop evaluates the objective by running iFEM per candidate layout and load sample, and that expensive inner evaluation is exactly where a trained surrogate (insertion point 3) is increasingly placed. Learning enters the placement problem through the surrogate, not through the search heuristic.

Interactive Tool — Virtual-Sensor & OOD Laboratory

A cantilever with sparse surface strain gauges, reconstructed three ways: (A) raw sparse physics inversion (integrate measured curvature), (B) GP strain completion feeding the same physics inversion, (C) a learned completion trained on load cases in the shaded window. Move the test load out of the window, add noise, or damage the specimen — and watch the persistent panel: who admits uncertainty, about what, and who fails silently.

Test load position $a$ 0.61

Load magnitude $P$ 0.80

Sensors $n_s$ 6

Noise $\sigma$ 0.020

GP length-scale $\ell$ 0.15

Damaged specimen: bending stiffness −40% on $x \in [0.2, 0.4]$ (the learned completion was trained on the pristine specimen)

Strain space — measurements, GP band, learned completion

Deflection space — truth vs. the three reconstructions

Four behaviors deserve deliberate replay, and the panel reports the error in two spaces because they do not tell the same story. In-window, the learned completion is the most accurate of the three even from very sparse sensors — which is empirical interpolation within the sampled range, not Section 2's span guarantee — the underlying fields gain a new kink at every unseen load position, so an interpolated load is not a linear combination of the training responses. Out-of-window, drag the load toward the free end and watch route C's strain-space error climb steadily until it is several times route A's, with no change in how confident its output looks; route A, which never knew there was a window, does not track the window at all — its error follows the geometry of the load, improving to the right and worsening to the left. Meanwhile the GP reports a band that reflects only sensor geometry, kernel and noise level — be careful here: this posterior variance is not conditioned on load position or structural state, so it does not widen merely because the load moved out of distribution. It is spatial interpolation uncertainty, useful for "how far am I from a sensor", useless as an OOD alarm.

Under specimen damage, the ordering flips again: route A degrades least, because $\kappa = \varepsilon/c$ is kinematics and holds whatever the stiffness, while B and C both fight a curvature field their priors cannot represent. Do not over-read it — A is not prior-free either (it interpolates curvature linearly between sensors and holds it constant outside them, so it cannot represent the curvature jumps at the damage boundaries), and with only one of six sensors inside the damaged span the whole effect is modest. And the fourth behavior is the one about measurement, not method: almost all of the above is visible in strain space and largely washed out in deflection space, because $\hat{w}$ is two integrations away from $\hat{\kappa}$ and the NRMSE is normalized by $\max|w|$, which itself grows as the load moves outboard. That is the very metric Section 10's protocol recommends. A smoothing, self-normalizing error measure can hide the failure you built the experiment to find — report the error in the space where the method actually operates, not only in the space you care about.

4. FEM as a Training-Data Factory — and the Sim-to-Real Gap

Every offline-trained map in this module — every amortized one, which is all of them except the per-instance PINN of Section 5 — needs (input, output) pairs. Where do (strain, displacement) pairs come from? Almost always from a finite element model. The factory is worth formalizing, because its two choices — what you sample and what you solve — end up inside the network weights.

The Synthetic Data Factory

Define a parameter vector $\mathbf{p}$ collecting load position, magnitude, direction, spatial distribution, and possibly boundary conditions and material scatter. Sample $\mathbf{p}_i$ from a chosen distribution (uniform grids or Latin hypercube in practice), solve the FEM problem for each sample, extract strains at the modeled sensor locations as inputs and the full-field displacement (or a subsampled DOF set) as targets, and inject synthetic measurement noise and sensor-dropout augmentation: $$\mathcal{D} \;=\; \left\{ \Big( \big(\mathbf{m}_i \odot [\boldsymbol{\varepsilon}(\mathbf{p}_i) + \boldsymbol{\eta}_i],\; \mathbf{m}_i\big),\; \mathbf{u}(\mathbf{p}_i)\Big) \right\}_{i=1}^{N}, \qquad \boldsymbol{\eta}_i \sim \mathcal{N}(\mathbf{0}, \sigma^2 \mathbf{I}), \quad \mathbf{p}_i \sim P_{\text{train}}$$ with $\mathbf{m}_i \in \{0,1\}^{n_s}$ a random channel mask — the dropout augmentation, written into the dataset rather than promised in prose. Note where the mask appears: it is part of the input, not only the corruption applied to it, because otherwise the network cannot tell a dropped channel from a gauge reading zero.

The critical epistemic point: the network never learns physics — it learns the FEM model evaluated over the sampled parameter distribution.

\theta^{\star} \;=\; \arg\min_{\theta} \; \mathbb{E}_{\,\mathbf{p} \sim P_{\text{train}},\; \boldsymbol{\eta},\; \mathbf{m}} \left\lVert f_{\theta}\big(\mathbf{m} \odot [\boldsymbol{\varepsilon}_{\text{FEM}}(\mathbf{p}) + \boldsymbol{\eta}],\; \mathbf{m}\big) - \mathbf{u}_{\text{FEM}}(\mathbf{p}) \right\rVert^{2}

Two error sources sit in that one expression. $\boldsymbol{\varepsilon}_{\text{FEM}}$ and $\mathbf{u}_{\text{FEM}}$ carry the model form; $P_{\text{train}}$ carries the sampling. Both are inherited by $\theta^\star$, and neither is visible at inference.

Model-form error (wrong constitutive fit, wrong boundary idealization) and sampling error (load cases you never generated) are baked into the weights silently. At inference the network produces fluent output either way; there is no residual to inspect, no assumption printed on the prediction.

The Cleanest Published Example: Tactile Labels No Available Instrument Supplies

The vision-based tactile sensing literature made this pattern explicit before most of the structural community. Sferrazza, Wahlsten, Trueeb & D'Andrea (2019) use a finite element analysis of a soft sensor pad to generate dense ground-truth contact force distributions and train a learning-based vision-based tactile sensor on them. Their stated motivation is the one to quote: the lack of ground truth sources for the entire contact force distribution has confined learning-based tactile sensing largely to total force and contact centre. That is an availability claim, not an impossibility theorem — no readily available, non-disruptive instrument supplies the full distribution at that density. Helmut, Dziarski, Funk, Belousov & Peters (2025) apply the same philosophy to commercial hardware, learning force-distribution estimation for the GelSight Mini from FEA-generated labels. The factory is not a convenience here; it is the only practical source of supervision at this density.

Trap — "ground truth" from FEM is model truth

FEM-generated labels inherit the constitutive model's error — critical for hyperelastic soft pads, where material fits are genuinely uncertain. A network trained on those labels can at best reproduce the FE model's opinion of the contact force. Call the labels what they are: model truth. The distinction is not rhetorical — it sets the accuracy ceiling of the whole learned sensor, and no amount of training data raises it.

The Sim-to-Real Gap Is the Factory's Price

Between the simulated training world and the physical structure sit: constitutive mismatch (hyperelastic parameter fits for elastomers are uncertain), geometric tolerances, and gauge-factor or camera-calibration errors. Standard mitigations, in increasing order of cost: randomize material and geometric parameters during data generation so the network cannot overfit one wrong model; augment with noise and sensor dropout so the map is not brittle to real hardware (training on noise-free synthetic strains is a classic self-inflicted wound — real gauges drift and jitter, and clean-data accuracy numbers do not survive contact with hardware); and fine-tune on a small measured dataset.

A synthesis observation — flagged as such, not yet a published result: the factory also runs in reverse. A validated iFEM running on real measured strains produces full-field reconstructions that can serve as pseudo-labels for training faster or nonlinear surrogates — the hybrid direction toward which the 2026 GNN + iFEM literature points.

The synthetic training-data factory. Left of the jagged line, everything is simulation: the FE model and the sampling distribution jointly define what $f_\theta$ can know. Right of the line, the real structure differs in constitutive behavior, geometry, and sensing chain — the sim-to-real gap. Bottom: the tactile instance (Sferrazza et al. 2019; Helmut et al. 2025), where FEM labels are the only practical supervision at this density.

5. Per-Instance Physics: PINNs for Shape Sensing and Inverse Elasticity

Everything so far learned from datasets. Physics-informed neural networks take the opposite bet: no offline amortization corpus — put the physics in the loss and fit one case at a time. They are not data-free: a per-instance PINN still consumes the measurements and boundary data for that instance, plus a collocation sample whose coverage matters, and it inherits whatever the assumed PDE gets wrong. Raissi, Perdikaris & Karniadakis (2019) defined the framework: a network $\mathbf{u}_\theta(\mathbf{x})$ represents the PDE solution; automatic differentiation of the network computes the PDE residual at collocation points; the training loss sums data misfit and residual terms. The decisive feature for inversion is the framework's "data-driven discovery" mode: unknown PDE coefficients become trainable variables, optimized jointly with $\theta$ by the same gradient descent — the inverse problem costs the same code as the forward one.

Physics-Informed Loss for Elastic Shape Sensing

The network maps coordinates to displacements; strains follow by automatic differentiation, so the strain–displacement relation is exact by construction; stress follows from the constitutive law; what remains to enforce is the data fit and momentum balance: $$\mathcal{L}(\theta) \;=\; \lambda_s \sum_{s=1}^{n_s} \left\lVert \boldsymbol{\varepsilon}\big(\mathbf{u}_{\theta}\big)(\mathbf{x}_s) - \bar{\boldsymbol{\varepsilon}}_s \right\rVert^2 \;+\; \lambda_p \int_{\Omega} \left\lVert \nabla\!\cdot\boldsymbol{\sigma}(\mathbf{u}_{\theta}) + \mathbf{b} \right\rVert^2 \, d\Omega \;+\; \lambda_{bc}\, \mathcal{L}_{\text{BC}}$$ $$\boldsymbol{\varepsilon} \;=\; \tfrac{1}{2}\left( \nabla \mathbf{u}_{\theta} + \nabla \mathbf{u}_{\theta}^{\mathsf{T}} \right), \qquad \boldsymbol{\sigma} \;=\; \lambda\,\mathrm{tr}(\boldsymbol{\varepsilon})\,\mathbf{I} + 2\mu\,\boldsymbol{\varepsilon}$$ For material identification, $(\lambda, \mu)$ — scalars or coefficient fields $\lambda_\phi(\mathbf{x}), \mu_\phi(\mathbf{x})$ — join the trainable variables.

SenseNet: the PINN Shape Sensor

Qiu, Arunachala & Linder (2023) built SenseNet from two components: a displacement-prediction network and a physics part computing the loss. The prior knowledge in the loss comprises the boundary conditions, the strain–displacement relation, the material constitutive equation, and the governing equation from balance of linear momentum. The method is mesh-free — which the authors highlight for complex geometries — and was validated against finite element solutions on bending tests (nonlinear displacement fields) and fixed tension tests (stress fields) in both 2D and 3D. A sensor-density study showed accuracy improving with more strain data. Their key claim against purely data-driven networks: because the physics is in the loss, performance does not rely on the choice of training data — there is no training distribution to fall out of.

The neighboring results fill out the family. Haghighat, Raissi, Moure, Gómez & Juanes (2021) established the reference PINN formulation for solid mechanics: a multi-network model — separate networks for displacement components and stress components, coupled through a constitutive residual — is more accurate than a single network, keeps the derivative order low, and extends to von Mises elastoplasticity; they also demonstrate transfer learning, with retraining on new parameters converging much faster than training from scratch. Zhang, Dao, Karniadakis & Suresh (2022) push to geometry identification: from displacement measurements placed on the outer boundary of a loaded specimen — deliberately, to mimic the real-world situation where internal details are unavailable — their PINN framework identifies the size, shape, and location of an internal void or inclusion, with constitutive models spanning linear elasticity, hyperelasticity, and plasticity, and additionally recovers the elastic modulus in a combined material-plus-geometry case (a soft circular inclusion). Note the two honest exceptions they report: the slender-slit case needs a handful of measurement points inside the solid, because boundary displacement is relatively insensitive to slit geometry, and the combined material-and-geometry case needs the same help. Mesh-free elasticity imaging, with the identifiability caveats attached. Chen & Gu (2023) demonstrate physics-informed deep learning across forward, inverse, and mixed elasticity problems in one framework. And Sahin, von Danwitz & Popp (2024) extend PINNs to forward and inverse problems of contact mechanics — directly relevant wherever the unknown includes contact, as on a tactile skin. For dynamics, Xu et al. (2024) fuse strain with acceleration measurements in one physics-informed network for static and dynamic displacement reconstruction — strain constrains the spatial shape, acceleration the temporal dynamics. Note carefully where that one sits in this module's taxonomy, because the label misleads: theirs is a physics-guided convolutional network with two input branches, trained on a dataset with the acceleration equation imposed as a constraint and multi-task loss weights balanced during training. That makes it a trained, amortized map carrying Section 4's full distribution dependence — not a network re-optimized per measurement case, and not an inheritor of SenseNet's "no training distribution to fall out of" claim. "Physics-informed" in a title tells you where the physics went, not whether the method is per-instance.

PINN architecture for inverse elasticity, after the multi-network formulation of Haghighat et al. (2021). Unknown material parameters (purple) are trained jointly with the networks — in their demonstrations as scalar Lamé constants; the coefficient-field variant $\lambda_\phi(\mathbf{x}), \mu_\phi(\mathbf{x})$ drawn in the box is the general form of the same idea, not something that paper shows. Four loss terms compete in one sum — and, per the NTK analysis of Section 6, do not converge at the same rate.

Honest Costs, Stated Before the Failure Modes

\text{iFEM: convex quadratic, one linear solve} \qquad \text{vs.} \qquad \text{PINN: nonconvex } \min_{\theta}\mathcal{L}, \text{ per-instance optimization}

iFEM minimizes a convex quadratic and solves one linear system. A vanilla PINN solves a nonconvex optimization — typically per load case at inference, unless amortized — with loss-weight tuning ($\lambda$ terms) and spectral bias as everyday practical difficulties. Standard training practice: normalize inputs and outputs, sample collocation points over the domain, weight the loss terms, optimize with Adam then L-BFGS. And note the vocabulary trap: "mesh-free" does not mean "fast" — per-instance PINN training is typically orders of magnitude slower than one precomputed linear solve, and the speed story in this module belongs to amortized operators (Section 7), not to PINNs. PINN inversion competes on flexibility: scattered irregular data assimilated naturally, some missing boundary-condition parameters inferable when the data are informative enough about them, joint state-plus-parameter estimation in one optimization. Read the middle item narrowly, because the rigid-body nullspace of Section 1 survives the change of solver intact: add a rigid translation or an infinitesimal rigid rotation to $\mathbf{u}_\theta$ and the strains, the stresses and the momentum residual are all unchanged, so a strain-only loss leaves the pose exactly as unobservable as iFEM does. Strain data can inform unknown traction or load parameters — with a known constitutive law the strains fix the stresses, hence the tractions, wherever the problem is identifiable. What no amount of strain or traction data fixes is the rigid-body pose: it is invariant to both. Displacement or pose anchors, or equivalent kinematic constraints, stay mandatory.

Trap — the silent factor of 2 in the data term

Measured rosette strains report engineering shear $\gamma_{xy} = 2\varepsilon_{xy}$; automatic differentiation of $\mathbf{u}_\theta$ produces the tensorial component $\varepsilon_{xy}$. Match them without converting and the shear channel of the data loss is silently wrong by a factor of 2 — the optimizer will happily fit the corrupted target, and nothing crashes. Fix the convention (Module 1) at the data-loading boundary and write it down.

6. When PINNs Fail — What a Low Loss Cannot Tell You

The PINN literature earned its credibility back by documenting its own failures. Two papers are load-bearing; internalize both before trusting any physics-informed inversion — including your own.

Krishnapriyan et al. (2021): on deceptively simple PDEs with convection, reaction, and diffusion operators, standard PINN training produces $O(1)$ errors once the PDE coefficient grows moderately large. The diagnosis matters more than the symptom: the soft PDE-residual penalty makes the loss landscape increasingly ill-conditioned — an optimization pathology, not a capacity limit. The same network represents the true solution just fine when trained on it directly; gradient descent simply cannot find it through the physics loss. Remedies with measured effect: curriculum regularization (ramp the difficult coefficient up during training) and sequence-to-sequence time marching (predict short segments instead of all of space-time at once), achieving up to 1–2 orders of magnitude lower error.

Wang, Yu & Perdikaris (2022): analyzing PINN gradient flow through the Neural Tangent Kernel shows that each loss component converges at a rate governed by its NTK eigenvalue spectrum. A large discrepancy between components means some terms — often the BC or data terms — train orders of magnitude slower than others, visible in practice as one loss plateauing while another collapses. Their fix: adaptive loss weights computed from the NTK,

\mathcal{L} = \sum_k \lambda_k\,\mathcal{L}_k, \qquad \lambda_k \;\propto\; \frac{\mathrm{tr}(\mathbf{K}_{\mathrm{NTK}})}{\mathrm{tr}\big(\mathbf{K}^{(k)}_{\mathrm{NTK}}\big)} \qquad \text{(NTK-balanced weights)}

Translated to Inverse Elasticity

Near-incompressibility $\nu \to 0.5$ stiffens the volumetric residual and worsens the loss conditioning — precisely the regime of silicone skins.
Sharp contact indentation produces high-spatial-frequency strain fields that collide with spectral bias: networks learn low frequencies first.
The parameter gradient can be swamped — the signal driving the unknown $(\lambda, \mu)$ competes with noisy residual gradients over thousands of collocation points.
Data noise makes identified moduli unstable, and the nonlinearity of the parameter map converts that instability into bias. Explicit parameter regularization buys stability by accepting a known bias — it is the classic trade, not a cure. Ill-posedness (Module 3) did not go away because the solver changed.

The mitigation checklist worth printing: nondimensionalize everything to $O(1)$; enforce Dirichlet BCs hard via a distance-function ansatz rather than penalty; use the mixed displacement–stress formulation to halve the derivative order; add Fourier features for sharp fields; balance loss weights adaptively (NTK- or gradient-norm-based); monitor the trajectory of the identified parameter, not just the total loss; run multiple seeds — PINN inversions have real run-to-run variance.

Trap — a low training loss proves neither uniqueness nor accuracy

The loss measures fit to the sampled data and the assumed residual at the sampled collocation points — nothing else. Multiple parameter fields can fit both to numerical precision (non-uniqueness survives intact); a wrong assumed load or BC model in the residual biases the reconstruction while driving the physics-residual term toward zero, leaving a nonzero data misfit as the only objection (the physics term pulls toward the assumed equations, not toward truth — so the total loss does not go to zero, and reading the sum alone hides which term is complaining); and a soft equilibrium penalty is never a certificate — it can reach zero when a compatible solution is representable, but it is only ever evaluated at the sampled collocation points, so a small value guarantees nothing off them. "Physics-informed" is a prior, not a proof. The dial below makes the bias mechanism tangible.

Interactive Tool — The Physics-Loss Dial

A degree-8 polynomial stands in for the network; the loss is data + $\lambda_p\,\times$ physics + BC penalties, solved exactly each frame. The physics residual always assumes a uniform load. Truth A matches that assumption; Truth B (point load) violates it. Turn the dial and watch regularization become bias.

Truth A: uniform load (assumed physics is right) Truth B: point load at $x=0.7$ (assumed physics is wrong)

Physics weight $\lambda_p = 10^{v}$, $v$ 0.0

Strain stations $n_s$ 8

Noise $\sigma$ 0.05

The moral: the physics term pulls toward the assumed equations. When they are right (Truth A), raising $\lambda_p$ tames noisy, wiggly fits into near-perfect reconstructions. When they are wrong (Truth B), the same dial bends the reconstruction away from the truth even at $\sigma = 0$, driving reconstruction error from a fraction of a percent at $\lambda_p = 10^{-4}$ to about 17% at $\lambda_p = 10^{4}$. Watch the two bars while you turn it, because what they do is the real lesson: the physics residual is driven to zero exactly as it would be if the assumption were right — it is measuring agreement with the assumed equations, so it cannot object — and only the data term objects. It does object, and it objects in proportion: at the default settings ($n_s = 8$, $\sigma = 0.05$) $\mathcal{L}_{\text{data}}$ climbs about an order of magnitude across the dial — from roughly half the noise floor $\sigma^2$ to some six times it — while the reconstruction error goes from about 2% to about 17%. So the objection is there. Read what it actually gives you: one number that says something here is inconsistent and never the assumed load model is wrong, legible only if you already know what the noise floor should have been, and only if you look at that term on its own. Inspect the terms separately; never read the sum alone.

7. Amortized Inversion: Neural Operators

Operator learning changes what is learned: not one solution but the solution operator $\mathcal{G}$ mapping an input function (load, coefficient field, boundary data) to an output function (displacement field), trained from many input–output pairs and queryable at any point — approximately discretization-invariant. This is the amortized end of insertion point 6: pay a large offline dataset-plus-training cost once, then evaluate in milliseconds forever after. Note which direction that buys you. The operator just defined is the forward map, and inverting through it still costs an optimization — the next subsection's pattern (a). Only a separately trained measurement-to-unknown map, or an NIO, turns an inversion itself into one forward pass.

The Two Canonical Architectures

DeepONet (Lu, Jin, Pang, Zhang & Karniadakis 2021), built on the universal approximation theorem for operators (Chen & Chen 1995, as cited therein): a branch net encodes the input function through its values at $m$ fixed sensors, a trunk net encodes the query coordinate $\mathbf{y}$, and the output is their inner product:

$$G_{\theta}(u)(\mathbf{y}) = \sum_{k=1}^{q} b_k\big(u(\mathbf{x}_1),\ldots,u(\mathbf{x}_m)\big)\; t_k(\mathbf{y}) + b_0$$

Fourier Neural Operator (Li et al. 2021): each layer applies a pointwise linear map plus a spectral convolution — FFT, truncate to $k_{\max}$ modes, multiply by learned complex weights $\mathbf{R}_\phi$, inverse FFT — so the parameters live in function space, not on a grid:

$$v_{l+1}(\mathbf{x}) = \sigma\Big(\mathbf{W}\,v_l(\mathbf{x}) + \mathcal{F}^{-1}\big[\mathbf{R}_{\phi}\cdot(\mathcal{F}v_l)\big](\mathbf{x})\Big)$$

Demonstrated on Burgers, Darcy flow, and Navier–Stokes; up to three orders of magnitude faster than traditional solvers at inference; and "the first ML-based method to successfully model turbulent flows with zero-shot super-resolution" — train coarse, evaluate fine.

Three Ways to Use an Operator for Inversion

Forward surrogate + gradient descent (insertion point 3): train $\mathcal{G}_\theta$ on the forward map, then invert by descending through the surrogate with Module-10 gradients. Fast per iteration — but the surrogate's gradient error is not controlled by its value error and must be validated separately against the true model's gradients. Differentiate in the variable you are inverting for, not in space: a surrogate $\widetilde{\mathcal{G}}(p) = \mathcal{G}(p) + \epsilon\sin(\omega p)$, with $p$ any one of the inferred parameters, is uniformly within $\epsilon$ of the true forward map while its parameter derivative is off by as much as $\epsilon\omega$. So a surrogate matching the forward map to $10^{-4}$ everywhere can still hand you descent directions pointing the wrong way; what needs validating against the true model is $D_{\mathbf{p}}\mathcal{G}$.
Direct inverse map $\mathbf{d} \mapsto \mathbf{p}$: fastest, most brittle — a plain regression from measurements to parameters, with everything Section 10 says about distribution shift.
Neural Inverse Operators (Molinaro, Yang, Engquist & Mishra 2023): the structural observation that a large class of PDE inverse problems — coefficient recovery from measurement data — are well-defined as maps from operators to functions: the datum is itself an operator (a boundary measurement map over many excitations). NIO composes DeepONet and FNO to learn such maps, reports robust, accurate solutions that significantly outperform baselines, and runs several orders of magnitude faster than direct and PDE-constrained optimization methods.

Operator learning in two architectures and three inversion patterns. DeepONet separates what function (branch) from where to evaluate (trunk); FNO parameterizes the layer in Fourier space, decoupling the learned operator from any one grid. The footer band is the practical menu for inversion.

The Break-Even Algebra Nobody Prints

"Up to $10^3\times$ faster" counts inference only. The dataset generation (thousands of FEM solves) and the training run are the hidden line items, and only the break-even count makes speed claims honest. With $C_{\text{per}}$ the cost of one per-instance inversion (a PINN training run, or an iterative physics inversion), amortization pays only when the number of inversions $N$ satisfies:

N \;>\; \frac{N_{\text{train}}\,C_{\text{solve}} + C_{\text{train}}}{C_{\text{per}} - C_{\text{infer}}} \qquad \text{valid only when } C_{\text{per}} > C_{\text{infer}}

Read the side condition, not just the fraction: if amortized inference is no cheaper than the per-instance route, the denominator is zero or negative and no $N$ ever recovers the offline cost. For a one-off material characterization, $N = 1$, and the offline cost is essentially never recovered unless $C_{\text{train}}$ and the dataset are negligible. For a tactile skin streaming force maps at camera rate, $N$ is millions per day and the operator wins by breakfast. The distinction to keep sharp — and the reason this page keeps PINNs and operators in separate sections:

	Per-instance PINN	Amortized neural operator
What is optimized	One network per measurement instance	One operator over a distribution of instances, offline
Training data	No offline corpus; per-instance measurements + BC data + a collocation sample	Thousands of FEM solves (Section 4 factory)
Inference cost	Full nonconvex optimization, minutes–hours	One forward pass, milliseconds
Distribution dependence	None claimed (SenseNet's design goal)	Total — valid on $P_{\text{train}}$, silent elsewhere
Natural niche	Data-poor, BC-uncertain, one-off inversions	High-rate repeated inversions of one configuration

Tactile-skin translation, with the arrow pointing the way the capability requires: generate an FEM dataset of (indenter shape, location, depth) $\to$ (marker displacement field, traction distribution), then train the operator on the inverse pairing, marker displacement field $\to$ traction distribution, and get millisecond force-map inference for real-time sensing. Train the forward direction instead — parameters $\to$ observations — and you have a surrogate, not a sensor: recovering tractions from it means gradient descent through the surrogate (pattern (a) above), which is not one forward pass. The out-of-distribution caveat is held until Section 10, where it becomes the main event.

8. Structure and Hybrids: Shallow Decoders, GNNs, Residual Correction

Architecture choice is a means, not the story — so this section is organized by what structural fact each architecture exploits, and closes with the hybrid pattern that keeps physics in the loop.

Shallow Decoders: Why Small Networks Suffice

Erichson, Mathelin, Yao, Brunton, Mahoney & Kutz (2020) showed for fluid flows that shallow decoder networks — small fully-connected nets from a handful of sensors to the full field — are remarkably effective, because the response of many physical systems lives near a low-dimensional manifold. This is the modern, nonlinear descendant of POD-based gappy reconstruction, and it explains why structural shape sensing — smooth, low-rank response spaces — rarely needs enormous networks:

\hat{\mathbf{u}} \;=\; \mathcal{D}_{\theta}(\mathbf{s}), \qquad \mathbf{s} \in \mathbb{R}^{n_s},\; n_s \ll n_{dof} \qquad \text{(shallow decoder: few sensors} \to \text{full field)}

For a fixed structure and fixed sensor set, the shallow MLP is the strong baseline that every fancier architecture must beat.

Graph Networks: When the Mesh Is the Structure

A finite element mesh is a graph — nodes are FE nodes, edges follow element connectivity — and message passing aggregates information over neighborhoods exactly where element assembly acts:

\mathbf{h}_i^{(k+1)} \;=\; \phi\!\left( \mathbf{h}_i^{(k)},\; \sum_{j \in \mathcal{N}(i)} \psi\!\left( \mathbf{h}_i^{(k)}, \mathbf{h}_j^{(k)}, \mathbf{e}_{ij} \right) \right)

Get the symmetry right, because the two versions of it say different things. The aggregation over a neighbourhood is invariant to the order of the neighbours; the node-level map as a whole is permutation-equivariant — relabel the nodes and the predicted fields come back relabelled the same way, which is exactly what a nodewise full-field output should do. Locality plus that equivariance plus weight sharing are what let one trained model be applied to a mesh of different size and connectivity at all. Whether it then transfers well is an empirical, distribution-dependent question, not something the symmetry guarantees. Lai, Wang, Li, Guan, Zhang & Xia (2026) demonstrate exactly that: transferable, adaptable full-field structural response reconstruction from sparse sensors via GraphSAGE–LSTM networks — GraphSAGE's sampled neighborhood aggregation buys transfer to graphs unseen in training, and the LSTM captures temporal correlation in dynamic response, echoing the strain-plus-acceleration fusion theme of Section 5.

The Hybrid: iFEM Stays in the Loop

Hong, Zhan, Guo, Liu, Zhu & Liu (2026) integrate graph neural networks with the inverse finite element method for high-resolution shape sensing and stress reconstruction of offshore wind-turbine towers — the emblematic hybrid: iFEM remains the physics backbone and the GNN supplies the resolution a sparse sensor set cannot. (That is the title-level description, and this page deliberately stops there — including on where the GNN sits. A strain-completion front end feeding iFEM and a post-solve enrichment of iFEM's output are different designs with different failure modes, and the title does not distinguish them. If you build on this paper, read the pipeline figure first.) The pattern is what makes it important: the learned component fills a gap the physics leaves open, and a physics layer rather than a network is what carries strain to displacement somewhere in the chain, so the reconstruction keeps a physical structure a pure regression would not have. Note the limit of that argument — and note that it takes two forms precisely because the ordering above is left open. If the learned stage sits upstream, nothing stops the network handing iFEM a plausible-but-wrong strain field, which iFEM will then faithfully reconstruct. If it sits downstream, nothing stops it moving a physically structured reconstruction off that structure again. Either way, unless the pipeline projects onto a constrained set or certifies a residual bound, "physics in the loop" does not on its own bound the error of what comes out.

Trap — not every GNN paper is a hybrid

Lai et al. (2026) is a standalone learned reconstruction — no iFEM anywhere in its loop. Hong et al. (2026) integrates the GNN with iFEM. Lumping every GNN reconstruction paper under "GNN + iFEM hybrid" misdescribes both: the standalone carries the distribution-shift risks of Section 10 with no iFEM in the loop — which is the claim this box is making, and is weaker than "no physics anywhere in the method" — while the hybrid inherits iFEM's assumptions along with its guarantees. Read the pipeline, not the keyword list.

Trap — hybrids must not inherit "material-free"

iFEM's material-free property covers displacement reconstruction only — Module 4 was explicit about this. The moment a hybrid outputs stress or damage indices, a constitutive law entered the pipeline: assumed (stress recovery from reconstructed strain) or learned (a network trained on FEM stress labels — which encode the constitutive model of the factory, Section 4). Either way, iFEM + DNN stress or damage predictions carry constitutive assumptions, and a hybrid's marketing must not launder them away under iFEM's flag.

Practical guidance, condensed: for a fixed structure and sensor set, start with an MLP or shallow decoder; reach for a GNN when you need mesh-level output, varying topology, or transfer across structures; add recurrent or temporal modules only for dynamics. Architecture is the last decision, not the first.

9. Head to Head: iFEM versus Learned Shape Sensing

The comparison the reader actually needs, on the axes that decide deployments:

Axis	iFEM	Calibration matrix	Trained network / operator	Per-instance PINN
Prior requirements	Mesh + kinematic model + sensor geometry	Known calibration cases — measured or simulated; simulated ones inherit the FE model that produced them	Large training set (usually synthetic — hence a model anyway)	PDE + constitutive assumption + BCs (partially relaxable)
Load-case generality	Load-agnostic by construction	Exact only within the training span (linear case)	Interpolates $P_{\text{train}}$; no out-of-distribution guarantee	No training distribution to leave
Noise behavior	Fixed linear gain: $\lVert\delta\mathbf{u}\rVert \le \lVert\mathbf{K}^{-1}\mathbf{B}\rVert\,\lVert\boldsymbol{\eta}\rVert$ — known in advance, set by the full transfer map, not by $\kappa(\mathbf{K})$ alone	Fixed linear gain, set by the composite map: $\lVert\delta\mathbf{u}\rVert \le \lVert\mathbf{C}\rVert\,\lVert\boldsymbol{\eta}\rVert$ with $\mathbf{C} = \mathbf{U}_{\text{train}}\mathbf{E}_{\text{train}}^{+}$. $1/\sigma_{\min}(\mathbf{E}_{\text{train}})$ bounds the coefficient amplification only: $\lVert\mathbf{C}\rVert \le \lVert\mathbf{U}_{\text{train}}\rVert/\sigma_{\min}(\mathbf{E}_{\text{train}})$	Local Lipschitz behavior unknown a priori	Noise destabilizes identified parameters; regularizing trades that for a known bias
Inference cost	RHS assembly + 2 triangular solves	One mat-vec	One forward pass	Full optimization per case
Nonlinearity & modality	Linear kinematics; strain inputs in the classical form (generalized variants add a displacement-misfit term)	Linear; sensor-vector inputs	Native: images, resistive skins, geometric/material nonlinearity	Nonlinear physics encodable in the loss
Self-diagnostics	The measured-sensor misfit term flags inconsistent data — that term alone, not the full functional value	None built in	Fails silently	Residual exists but measures the assumed physics
Certification story	Mesh + residual + linear theory: arguable	Linear algebra: arguable in-span	Open problem	Open problem

The noise row deserves its equation, because it is the cleanest structural difference:

\delta \mathbf{u}_{\text{iFEM}} \;=\; \mathbf{K}^{-1} \mathbf{B}\,\boldsymbol{\eta} \quad \text{(fixed linear noise gain, } \lVert \mathbf{K}^{-1}\mathbf{B} \rVert \text{)} \qquad \text{vs.} \qquad \lVert f_{\theta}(\boldsymbol{\varepsilon} + \boldsymbol{\eta}) - f_{\theta}(\boldsymbol{\varepsilon}) \rVert \;\le\; L_{\theta}(\boldsymbol{\varepsilon})\, \lVert \boldsymbol{\eta} \rVert \quad \text{(unknown local Lipschitz)}

Note which matrix does the bounding. The amplification is governed by the norm of the composite transfer map $\mathbf{K}^{-1}\mathbf{B}$, not by $\kappa(\mathbf{K})$ on its own: a well-conditioned $\mathbf{K}$ paired with a large $\lVert\mathbf{B}\rVert$ still amplifies, and $\kappa(\mathbf{K})$ bounds only relative error in any case. The structural point survives the correction — the gain is a fixed, computable number known before deployment, which is exactly what $L_\theta(\boldsymbol{\varepsilon})$ is not.

On certification: a physics method with a mesh and a residual is easier to argue before a review board than a black box — but state this as the field's open problem, not a solved verdict. Nobody has yet certified either route for safety-critical shape sensing, and the honest sentence is that the physics route has more arguable structure, not more approvals.

The Anchor Study and the Counterexample

De Mooij & Martinez (2024) is the anchor because its design is the template for honest comparisons: literature benchmarks plus the twisted, tapered NACA 6412 blade, hexahedral solid elements, mixed displacement/strain sensor sets, both accuracy and cost scored, motivated by load-monitoring with discrete, irregularly distributed sensors. Outcome on those cases: CM below 0.01% average displacement and strain error against 21% and 99% for their iFEM implementation, with CM repeat solutions roughly 100× faster after set-up — conditional, as Section 2 established, on in-span load cases and those sensor layouts, not a general verdict.

And the regime where learning is the demonstrated route: soft robots. Truby, Della Santina & Rus (2020) reconstruct the 3D configuration of soft, sensorized robots from distributed embedded sensors via deep learning, reporting that their piezoresistive sensors give "hysteretic, non-monotonic feedback". Take that at its actual strength, which is weaker than "learning wins": their stated contribution is a kirigami-enabled sensorization strategy, a general kinematic description, and an investigation of network designs for predicting configuration — not a benchmark against model-based inversion of any kind, which they do not run. That an elastomeric body with hysteretic, non-monotonic sensors falls outside the small-strain model class is this guide's mechanics inference from those sensor characteristics, not a result the paper measures — and it certainly does not show that no physics-based inversion could have worked. Zhang, Wang, Truby, Chin & Rus (2023) follow with machine-learning best practices for soft robot proprioception. When a particular model class is wrong, no method built on that class is safe to prefer — which says nothing about methods built on a better one.

Key insight — complementary, not competing

Every axis in the table trades on what you can supply: a trustworthy model, known load cases, a large simulation budget, or per-case compute. Among the papers surveyed here, the later ones compose rather than pick sides — Hong et al. integrate a GNN with iFEM rather than replacing it. A reading list assembled to populate a taxonomy cannot date a turn in a field, so read that as the shape of this page's sample, not as a period claim. The remaining question is Section 12's: which stage of your inversion earns the learned component.

10. Generalization, Leakage, and Out-of-Distribution Honesty

"Does it generalize?" is not one question. Formalize it: the trained map is pinned down only on the support of $P_{\text{train}}$ in load space. Distinguish:

\mathbf{p}_{\text{test}} \in \operatorname{supp}(P_{\text{train}}) \;\; \text{(in-distribution)} \qquad \text{vs.} \qquad \mathbf{p}_{\text{test}} \notin \operatorname{supp}(P_{\text{train}}) \;\; \text{(out-of-distribution, no guarantee)}

The convex hull $\operatorname{conv}\{\mathbf{p}_i\}_{i=1}^{N}$ of the training samples is the usual stand-in for that test, because the hull is computable and the support is not. Keep it in its place: it is a geometric heuristic, not the criterion. The hull generally contains large regions the support never reached — a ring-shaped or discrete load distribution has a hull full of never-sampled points — so "inside the hull" neither implies in-distribution nor certifies anything about a nonlinear learned map. The figure below is drawn with a hull for exactly that reason, and its caption says so.

And connect to the linear theory: for a linear structure, superposition makes the CM / linear-regression map exact on the span of the training loads — so apparent "generalization" in linear demos is often just linearity, and says nothing about nonlinear or out-of-span behavior. The concrete shift sources for a deployed shape sensor, in rough order of likelihood: unseen load positions and multi-load combinations; changed boundary conditions; temperature strains superposed on mechanical strains; sensor drift and dropout; and damage-induced stiffness change — which shifts the strain pattern precisely when monitoring matters most.

Load-space generalization. The learned map is empirically reliable within the sampled range and increasingly suspect outside it. Resist upgrading that to a guarantee: convex-hull membership certifies nothing for a nonlinear learned map, and even here the underlying fields acquire a new kink at every unseen load position, so an interpolated load is not a linear combination of the training responses. Exactness belongs to the linear case — a genuine linear superposition of training loads, with a calibration map of sufficient rank. iFEM's validity region is the entire plane, bounded not by data coverage but by its model assumptions. The two regions fail on orthogonal axes.

Leakage: the Way Papers Fool Themselves

Trap — random splits leak load cases

Splitting samples randomly puts frames from the same load case on both sides of the train/test divide; the network memorizes the case, the test score inflates, and the paper reports "generalization" it never tested. Split by load case — more generally by specimen, loading path, or experiment — and never by sample. This single protocol error accounts for a healthy share of too-good-to-be-true numbers in the applied literature.

Noise, Uncertainty, and Physics as the Robustness Lever

Contrast the fixed linear noise gain of iFEM with a network's data-dependent sensitivity (Section 9's equation). Standard mitigation is training-time noise and dropout augmentation (Section 4), plus ensembling for uncertainty estimates — disagreement across an ensemble is the cheapest usable OOD signal a regression network offers. The stronger lever is physics: SenseNet's explicitly stated design goal is that incorporating the physics of the problem makes performance not rely on the choice of training data — read that at its actual size: a physics-informed loss can reduce dependence on an offline labelled-data distribution, but it does not buy distribution-independence outright — a per-instance fit still depends on collocation coverage and on the assumed PDE, domain and BCs, and a physics-guided network trained offline (Section 5) keeps its training distribution in full. Hybrids operationalize the same idea structurally: GNN + iFEM (Hong et al. 2026) and pre-extrapolation + iFEM (Oboe et al. 2022) keep a physics layer so that the upstream component — learned in the first case, analytical and model-based in the second — only fills gaps rather than carrying the whole inversion. That architecture and training decisions materially change generalization — and that best-practice protocols are now publishable results in themselves — is documented systematically for soft-robot proprioception by Zhang et al. (2023).

OOD Detection You Can Actually Deploy

A learned map fails silently; a partial defence is to bolt a physics residual onto it. Run the reconstruction back through a forward model — or, when an iFEM layer exists, monitor its residual online: measured strains inconsistent with any displacement field in the model class push it up, and a spike is a label-free alarm. Monitor the right quantity, though, or the alarm is worthless. The functional's total value is not a residual: it also contains the $w_{\min}$-weighted terms that push uninstrumented elements toward a pseudo-target of zero, and those terms grow roughly with the square of the load even when every measurement is perfectly compatible, because valid nonzero strain in a dark element is scored as misfit. Track the measured-sensor misfit separately, whiten it by the expected noise covariance so its scale is interpretable, and set a load-aware threshold. Then read it in one direction only: a high whitened misfit is good evidence something is inconsistent, but a low one certifies nothing. It is blind to errors living in the model’s nullspace, to OOD states the model happens to explain, and to anything the residual does not observe — so treat it as a necessary consistency check to be paired with independent validation and explicit uncertainty, never as an OOD certificate. This is iFEM's self-diagnostic (Section 9, row 6) recycled as a watchdog for its learned replacement — a compatibility alarm, not a general self-diagnosis — and it is the cheapest form of the hybrid argument.

The Evaluation Protocol (adopt verbatim)

Split by load case — never randomly by sample.
Evaluate a noise sweep, not one noise level.
Report error normalized by maximum deflection: $$\text{NRMSE} \;=\; \frac{ \sqrt{ \tfrac{1}{n} \sum_k \left( \hat{w}_k - w_k \right)^2 } }{ \max_k \lvert w_k \rvert }, \qquad \max_k \lvert w_k \rvert > 0$$ State that side condition and honour it: at a zero or near-zero reference state the denominator vanishes or blows the ratio up, so report absolute RMSE there, or normalize by a fixed engineering reference scale instead of by the realized maximum. (Note also what the normalization does when it is defined: it rescales the error by a quantity that itself moves with the load case — see the lab in Section 3.)
Test at least one structurally different condition: an unseen boundary condition or load type.
If iFEM is available, always report it as the physics baseline.

The Virtual-Sensor & OOD Laboratory in Section 3 is this section made tangible: replay its presets with the panel open and watch which method's error against the simulation truth moves when the load leaves the window — and then notice that none of the three tells you it has. The GP band is spatial interpolation uncertainty: it widens away from sensors, not when the load leaves the training window, so it cannot serve as the changed-load alarm. The learned route has no uncertainty estimate at all, and the warning icon beside its error is a simulation-oracle annotation drawn from truth the estimator never sees. That absence is the lesson the lab exists to deliver: a changed-load OOD alarm is precisely what none of these three methods gives you for free, which is why the watchdog above is bolted on from outside.

11. Case Study: the Tactile Skin, Learned-Map Angle

Vision-based tactile sensing is the sibling inverse problem to iFEM shape sensing — with the sparsity regime inverted. Measure a field on or inside a soft elastic pad (camera-tracked marker displacements or image features: dense data, the opposite of strain-gauge scarcity), and infer the contact traction distribution and the deformed shape. It is an ill-posed elastic inverse problem that needs regularization either by physics or by a learned prior:

\mathbf{d} \;=\; \mathcal{M}(\mathbf{t}) \;\approx\; \mathbf{G}\,\mathbf{t}, \qquad \mathbf{G} \;=\; \left.\frac{\partial \mathcal{M}}{\partial \mathbf{t}}\right\rvert_{\mathbf{t} = \mathbf{0}} \quad \text{(forward map, and its small-deformation tangent)}, \qquad (\hat{\mathbf{t}}, \hat{\mathbf{u}}) \;=\; g_{\theta}(\mathbf{d}) \quad \text{(learned inverse)}

\hat{\mathbf{t}} \;=\; \arg\min_{\mathbf{t}} \; \lVert \mathbf{G}\mathbf{t} - \mathbf{d} \rVert^2 + \lambda \, \mathcal{R}(\mathbf{t}) \quad \text{(physics-regularized alternative — Module 8's route)}

Write the forward map nonlinearly and linearize on purpose. $\mathbf{d}$ is what the camera actually delivers — the observed marker or feature displacement samples, not a reconstructed field — and the two outputs of $g_\theta$ are two separate estimation jobs: the traction distribution $\hat{\mathbf{t}}$ and the dense deformation $\hat{\mathbf{u}}$ each need their own labels and their own loss term, and a network trained on force labels alone returns only the first. $\mathcal{M}$ is the hyperelastic traction-to-marker-displacement map; the constant matrix $\mathbf{G}$ is its tangent at the undeformed state, valid only for indentations light enough that the pad stays in its linear range — which is precisely the assumption the next subsection says a soft skin violates. The regularized least-squares form inherits that caveat: it is the linearized problem, not the one the hardware poses.

Module 8 owns the model-based mechanics of tactile force inversion; this section covers only the learned-map angle and the correspondence that lets you transfer intuition between the two problems:

The same inverse problem twice. Every level has a counterpart — and the bottom row is the one that costs deployments: the physics column ships with a self-check, the learned column needs uncertainty quantification bolted on.

Why Not Just Run iFEM on the Skin?

Three reasons, all structural. The pad is hyperelastic and routinely sees large strains, violating the small-strain kinematics of standard inverse elements — the model-based baseline breaks before the comparison starts, and any fair evaluation must say so. The sensor modality is wrong for the classical strain-input form: raw images are not strain components, and a marker field only becomes usable once tracking has turned it into displacements — which a generalized displacement-misfit variant could then accept, at the price of a data term the strain-only functional does not have. And contact is often blamed for this, but be precise: unknown contact tractions are loads, and load-free displacement iFEM never needed them. Read that for exactly what it buys, though: load-agnosticism says iFEM can recover the shape without knowing the tractions — not that it can recover the tractions, and traction is half of the task this section stated. Getting $\mathbf{t}$ back needs a constitutive law and a contact model bolted on top, so iFEM's load-agnosticism hands you the deformed shape and nothing more. What actually breaks are the things iFEM does depend on — the pose and essential anchors, the geometry and sensor map, the strain modality, and the small-strain kinematics a soft skin cheerfully violates. This is why the published pattern for skins is the Section 4 factory: Sferrazza et al. (2019) train on FEM-generated force-distribution labels; Helmut et al. (2025) do so for the commercial GelSight Mini; Truby et al. (2020) map distributed embedded sensor signals to whole-body 3D configuration by deep learning.

What iFEM thinking still contributes, as transferable principles: weighted least-squares functionals as the template for fusing heterogeneous measurements; the residual as an online consistency check (Section 10's watchdog); conditioning analysis for marker and sensor layout — the placement reasoning of Section 3 applies verbatim to marker density; and the model-distilled-into-data caveat — FEM labels inherit the hyperelastic model's constitutive error, so "ground truth" is model truth. A Mindlin-type inverse-shell treatment of a sensorized skin is the natural physics baseline against which learned skins should be benchmarked — where its small-strain assumptions hold, it is the honest yardstick; where they break, documenting that is itself the comparison.

12. A Practitioner's Decision Procedure

The module, converted into the decision you will actually face:

Linear structure, decent sensor coverage, geometry known → plain iFEM. Nothing to learn: inference is already real-time and the residual gives self-diagnosis.
Sensor-starved but linear → keep iFEM; add strain completion — physics-based (Oboe et al. 2022) or GP with uncertainty (Poloni et al. 2023) — or optimize placement before hardware is committed (Module 6; Ghasemzadeh & Kefal 2022). Remember what the completion smuggles in (Section 3).
Known load classes, no trustworthy model, calibration loads applicable → calibration matrix (de Mooij & Martinez 2024), respecting the span limitation.
Nonlinear, soft, or camera-based sensing → learned map trained on FEM-generated labels — the Sferrazza et al. (2019) pattern is real sensor images and optical-flow features paired with FEA-derived force-distribution labels, with the material model characterized experimentally and held fixed. Add synthetic noise and material/geometry randomization on top as this guide's own sim-to-real recommendation (Section 4), not as something that paper reports. Shallow MLP first (Erichson et al. 2020's lesson: small decoders suffice for low-rank response spaces); GNN only if mesh-level output or transfer across geometries is needed (Lai et al. 2026); temporal module only for dynamics.
Extrapolation-critical or data-poor → physics-informed loss, per-instance (SenseNet: Qiu et al. 2023), accepting the per-case optimization cost and carrying Section 6's failure-mode checklist. Keep the neighbouring option distinct: a physics-guided network trained offline (Xu et al. 2024 fuse strain with acceleration this way) buys cheap inference but is a trained map, so item 4's training-distribution caveats apply to it in full — it does not get the per-instance route's freedom from a training distribution.
Certification-sensitive or real-time at scale → hybrid: iFEM as the final estimator with ML as pre-processor, monitoring the iFEM measured-sensor misfit online (that term, whitened and load-aware — not the total functional value, Section 10). (Hong et al. 2026 is the published instance of keeping iFEM in the loop rather than replacing it; which side of the solve their GNN sits on is not something this page settles — Section 8.) Or an amortized operator with an OOD watchdog and a physics fallback, if the break-even algebra of Section 7 clears.

Build checklist, with typical orders of magnitude (practice guidance, not citation): validate the FE model statically before trusting it as a data factory; expect thousands to tens of thousands of FEM solves for smooth strain-to-displacement maps; z-score inputs; hold out entire load cases; sweep noise at inference; report NRMSE against maximum deflection wherever that maximum is nonzero, and absolute RMSE where it is not; and compare against the iFEM baseline in every experiment — no exceptions, including the experiments where it loses.

The module's thesis

The mature question is not "iFEM or ML?" but: which stage of the inversion earns a learned component, and which keeps the physics? Answer it per stage — completion, prior, surrogate, refinement, placement, or the whole map — and every paper in this module falls into place.

Flashcards

References

Chen, Chun-Teh; Gu, Grace X. (2023). Physics-Informed Deep-Learning For Elasticity: Forward, Inverse, and Mixed Problems. Advanced Science 10(18) 2300439.
Cornelis de Mooij, Marcias Martinez (2024). A Critical Comparison of Shape Sensing Algorithms: The Calibration Matrix Method versus iFEM. Sensors.
N. Benjamin Erichson, Lionel Mathelin, Zhewei Yao, Steven L. Brunton, Michael W. Mahoney, J. Nathan Kutz (2020). Shallow neural networks for fluid flow reconstruction with limited sensors. Proceedings of the Royal Society A.
Ghasemzadeh, M.; Kefal, A. (2022). Sensor Placement Optimization for Shape Sensing of Plates and Shells Using Genetic Algorithm and Inverse Finite Element Method. Sensors.
Gherlone, Marco; Cerracchio, Priscilla; Mattone, Massimiliano (2018). Shape sensing methods: Review and experimental comparison on a wing-shaped plate. Progress in Aerospace Sciences.
Haghighat, E.; Raissi, M.; Moure, A.; Gómez, H.; Juanes, R. (2021). A physics-informed deep learning framework for inversion and surrogate modeling in solid mechanics. Computer Methods in Applied Mechanics and Engineering.
Erik Helmut, Luca Dziarski, Niklas Funk, Boris Belousov, Jan Peters (2025). Learning Force Distribution Estimation for the GelSight Mini Optical Tactile Sensor Based on Finite Element Analysis. IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS); arXiv:2411.03315.
Hong, Kai; Zhan, Jiazhen; Guo, Yuhao; Liu, Lei; Zhu, Dongxu; Liu, Gang (2026). High-resolution shape sensing and stress reconstruction for offshore wind-turbine towers: A framework integrating graph neural networks with the inverse finite element method. Ocean Engineering.
Huang, Tianxiang; Yuan, Shenfang; Chen, Jian; Dong, Tianyu; Duan, Wenpeng (2024). Thermal deformation monitoring of large-scale composite honeycomb spaceborne antennas with limited strain measurements. Aerospace Science and Technology 155 109665.
Krishnapriyan, A. S.; Gholami, A.; Zhe, S.; Kirby, R. M.; Mahoney, M. W. (2021). Characterizing possible failure modes in physics-informed neural networks. NeurIPS 2021.
Keyu Lai, Xiaoyou Wang, Yixian Li, Hong Guan, Yiming Zhang, Yong Xia (2026). Transferable and adaptable full-field structural response reconstruction from sparse sensors via GraphSAGE–LSTM neural networks. Engineering Structures.
Li, Z.; Kovachki, N.; Azizzadenesheli, K.; Liu, B.; Bhattacharya, K.; Stuart, A.; Anandkumar, A. (2021). Fourier Neural Operator for Parametric Partial Differential Equations. ICLR 2021.
Lu, L.; Jin, P.; Pang, G.; Zhang, Z.; Karniadakis, G. E. (2021). Learning nonlinear operators via DeepONet based on the universal approximation theorem of operators. Nature Machine Intelligence.
Molinaro, Roberto; Yang, Yunan; Engquist, Björn; Mishra, Siddhartha (2023). Neural Inverse Operators for Solving PDE Inverse Problems. Proceedings of the 40th International Conference on Machine Learning (ICML), PMLR 202, pp. 25105–25139.
Daniele Oboe, Claudio Sbarufatti, Marco Giglio (2022). Physics-based strain pre-extrapolation technique for inverse Finite Element Method. Mechanical Systems and Signal Processing.
Poloni, Dario; Oboe, Daniele; Sbarufatti, Claudio; Giglio, Marco (2023). Towards a stochastic inverse Finite Element Method: A Gaussian Process strain extrapolation. Mechanical Systems and Signal Processing 189 110056.
Yitao Qiu, Prajwal Kammardi Arunachala, Christian Linder (2023). SenseNet: A Physics-Informed Deep Learning Model for Shape Sensing. Journal of Engineering Mechanics (ASCE).
Raissi, M.; Perdikaris, P.; Karniadakis, G. E. (2019). Physics-informed neural networks: A deep learning framework for solving forward and inverse problems involving nonlinear partial differential equations. Journal of Computational Physics.
Sahin, Tarik; von Danwitz, Max; Popp, Alexander (2024). Solving forward and inverse problems of contact mechanics using physics-informed neural networks. Advanced Modeling and Simulation in Engineering Sciences 11, article 11.
Sferrazza, Carmelo; Wahlsten, Adam; Trueeb, Camill; D'Andrea, Raffaello (2019). Ground Truth Force Distribution for Learning-Based Tactile Sensing: A Finite Element Approach. IEEE Access.
Tessler, Alexander; Spangler, Jan L. (2005). A least-squares variational method for full-field reconstruction of elastic deformations in shear-deformable plates and shells. Computer Methods in Applied Mechanics and Engineering.
Ryan L. Truby, Cosimo Della Santina, Daniela Rus (2020). Distributed Proprioception of 3D Configuration in Soft, Sensorized Robots via Deep Learning. IEEE Robotics and Automation Letters.
Wang, S.; Yu, X.; Perdikaris, P. (2022). When and why PINNs fail to train: A neural tangent kernel perspective. Journal of Computational Physics.
Kaikai Xu, Qiangyong Wang, Xuesong Yang, Ding Ding, Zifeng Zhao, Zhicheng Hu, Xuelin Wang (2024). Novel physics-informed neural network approach for dynamic and static displacement reconstruction via strain and acceleration. Measurement.
Annan Zhang, Tsun-Hsuan Wang, Ryan L. Truby, Lillian Chin, Daniela Rus (2023). Machine Learning Best Practices for Soft Robot Proprioception. IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS).
Zhang, E.; Dao, M.; Karniadakis, G. E.; Suresh, S. (2022). Analyses of internal structures and defects in materials using physics-informed neural networks. Science Advances.

← 10. Adjoints & Differentiable FEM 12. Digital Twins & Frontiers →