Regularization (SimPEG.regularization)#

Regularization classes are used to impose constraints on models recovered through geophysical inversion. Constraints may be straight forward, such as: requiring the recovered model be spatially smooth, or using a reference model to add a-priori information. Constraints may also be more sophisticated; e.g. cross-validation and petrophysically-guided regularization. In SimPEG, constraints on the recovered model can be defined using a single Regularization object, or defined as a weighted sum of Regularization objects.

Basic Theory#

Most geophysical inverse problems suffer from non-uniqueness; i.e. there is an infinite number of models (\(m\)) capable of reproducing the observed data to within a specified degree of uncertainty. The challenge is recovering a model which 1) reproduces the observed data, and 2) reasonably approximates the subsurface structures responsible for the observed geophysical response. To accomplish this, regularization is used to ensure the solution to the inverse problem is unique and is geologically plausible. The regularization applied to solve the inverse problem depends on user assumptions and a priori information.

SimPEG uses a deterministic inversion approach to recover an appropriate model. The algorithm does this by finding the model (\(m\)) which minimizes a global objective function (or penalty function) of the form:

\[\phi (m) = \phi_d (m) + \beta \, \phi_m (m)\]

The global objective function contains two terms: a data misfit term \(\phi_d\) which ensures data predicted by the recovered model adequately reproduces the observed data, and the model objective function \(\phi_m\) which is comprised of one or more regularization functions (objective functions) \(\phi_i (m)\). I.e.:

\[\phi_m (m) = \sum_i \alpha_i \, \phi_i (m)\]

The model objective function imposes all the desired constraints on the recovered model. Constants \(\alpha_i\) weight the relative contributions of the regularization functions comprising the model objective function. The trade-off parameter \(\beta\) balances the relative contribution of the data misfit and regularization functions on the global objective function.

Regularization classes within SimPEG correspond to different regularization (objective) functions that can be used individually or combined to define the model objective function \(\phi_m (\mathbf{m})\). For example, a combination of regularization functions that ensures the values in the recovered model are not too large and are spatially smooth in the x and y-directions can be expressed as:

\[\phi_m (m) = \alpha_s \! \int_\Omega \Bigg [ \frac{1}{2} w_s(r) \, m(r)^2 \Bigg ] \, dv + \alpha_x \! \int_\Omega \Bigg [ \frac{1}{2} w_x(r) \bigg ( \frac{\partial m}{\partial x} \bigg )^2 \Bigg ] \, dv + \alpha_y \! \int_\Omega \Bigg [ \frac{1}{2} w_y(r) \bigg ( \frac{\partial m}{\partial y} \bigg )^2 \Bigg ] \, dv\]

where \(w_s(r), w_x(r), w_y(r)\) are user-defined weighting functions. For practical implementation within SimPEG, the regularization function and all its dependent variables are discretized to a numerical grid (or mesh). The model is therefore defined as a discrete set of model parameters \(\mathbf{m}\). And the regularization is implemented using a weighted sum of objective functions:

\[\phi_m (\mathbf{m}) \approx \frac{\alpha_s}{2} \big \| \mathbf{W_s m} \big \|^2 + \frac{\alpha_x}{2} \big \| \mathbf{W_x G_x m} \big \|^2 + \frac{\alpha_y}{2} \big \| \mathbf{W_y G_y m} \big \|^2\]

where \(\mathbf{G_x}\) and \(\mathbf{G_y}\) are partial gradient operators along the x and y-directions, respectively. \(\mathbf{W_s}\), \(\mathbf{W_x}\) and \(\mathbf{W_y}\) are weighting matrices that apply user-defined weights and account for cell dimensions in the inversion mesh.

The API#

Weighted Least Squares Regularization#

Weighted least squares regularization functions are defined as weighted L2-norms on the model, its first-order directional derivative(s), or its second-order directional derivative(s).

WeightedLeastSquares(mesh[, active_cells, ...])

Weighted least-squares regularization using smallness and smoothness.

Smallness(mesh, **kwargs)

Smallness regularization for least-squares inversion.

SmoothnessFirstOrder(mesh[, orientation, ...])

First-order smoothness least-squares regularization.

SmoothnessSecondOrder(mesh[, orientation, ...])

Second-order smoothness (flatness) least-squares regularization.

Sparse Norm Regularization#

Sparse norm regularization allows for the recovery of compact and/or blocky structures. An iteratively re-weighted least-squares approach allows smallness and smoothness regularization functions to be defined using norms between 0 and 2.

Sparse(mesh[, active_cells, norms, ...])

Sparse norm weighted least squares regularization.

SparseSmallness(mesh[, norm, irls_scaled, ...])

Sparse smallness (compactness) regularization.

SparseSmoothness(mesh[, orientation, ...])

Sparse smoothness (blockiness) regularization.

Vector Regularizations#

Vector regularization allows for the recovery of vector models; that is, a model where the parameters for each cell define directional components of a vector quantity.

CrossReferenceRegularization(mesh, ref_dir)

Cross reference regularization for models representing vector quantities.

VectorAmplitude(mesh[, mapping, active_cells])

Sparse vector amplitude regularization.

AmplitudeSmallness(mesh[, norm, ...])

Sparse smallness regularization on vector amplitudes.

AmplitudeSmoothnessFirstOrder(mesh[, ...])

Sparse amplitude smoothness (blockiness) regularization.

Joint Regularizations#

Regularization functions for joint inversion involving one or more physical properties.

CrossGradient(mesh, wire_map[, approx_hessian])

Cross-gradient regularization for joint inversion.

JointTotalVariation(mesh, wire_map[, eps])

Joint total variation regularization for joint inversion.

PGI(mesh, gmmref[, alpha_x, alpha_y, ...])

Regularization function for petrophysically guided inversion (PGI).

PGIsmallness(gmmref[, gmm, wiresmap, ...])

Smallness regularization function for petrophysically guided inversion (PGI).

LinearCorrespondence(mesh, wire_map[, ...])

Linear correspondence regularization for joint inversion with two physical properties.

Base Regularization Classes#

Base regularization classes. Inherited by other classes and not used directly to constrain inversions.

RegularizationMesh(mesh[, active_cells])

Regularization Mesh

BaseRegularization(mesh[, active_cells, ...])

Base regularization class.

BaseSimilarityMeasure(mesh, wire_map, **kwargs)

Base regularization class for joint inversion.

BaseSparse(mesh[, norm, irls_scaled, ...])

Base class for sparse-norm regularization.

BaseVectorRegularization(mesh[, ...])

Base regularization class for models defined by vector quantities.

BaseAmplitude(mesh[, active_cells, mapping, ...])

Base amplitude regularization class for models defined by vector quantities.