SimPEG.regularization.Smallness#
- class SimPEG.regularization.Smallness(mesh, **kwargs)[source]#
Bases:
BaseRegularization
Smallness regularization for least-squares inversion.
Smallness
regularization is used to ensure that differences between the model values in the recovered model and the reference model are small; i.e. it preserves structures in the reference model. If a reference model is not supplied, the starting model will be set as the reference model in the corresponding objective function by default. Optionally, custom cell weights can be included to control the degree of smallness being enforced throughout different regions the model.See the Notes section below for a comprehensive description.
- Parameters:
- mesh
regularization.RegularizationMesh
Mesh on which the regularization is discretized. Not the mesh used to define the simulation.
- active_cells
None
, (n_cells
, )numpy.ndarray
of
bool Boolean array defining the set of
RegularizationMesh
cells that are active in the inversion. IfNone
, all cells are active.- mapping
None
,SimPEG.maps.BaseMap
The mapping from the model parameters to the active cells in the inversion. If
None
, the mapping is the identity map.- reference_model
None
, (n_param
, )numpy.ndarray
Reference model. If
None
, the reference model in the inversion is set to the starting model.- units
None
,str
Units for the model parameters. Some regularization classes behave differently depending on the units; e.g. ‘radian’.
- weights
None
,dict
Weight multipliers to customize the least-squares function. Each key points to a (n_cells, ) numpy.ndarray that is defined on the
regularization.RegularizationMesh
.
- mesh
Notes
We define the regularization function (objective function) for smallness as:
\[\phi (m) = \int_\Omega \, w(r) \, \Big [ m(r) - m^{(ref)}(r) \Big ]^2 \, dv\]where \(m(r)\) is the model, \(m^{(ref)}(r)\) is the reference model and \(w(r)\) is a user-defined weighting function.
For implementation within SimPEG, the regularization function and its variables must be discretized onto a mesh. The discretized approximation for the regularization function (objective function) is expressed in linear form as:
\[\phi (\mathbf{m}) = \sum_i \tilde{w}_i \, \bigg | \, m_i - m_i^{(ref)} \, \bigg |^2\]where \(m_i \in \mathbf{m}\) are the discrete model parameter values defined on the mesh and \(\tilde{w}_i \in \mathbf{\tilde{w}}\) are amalgamated weighting constants that 1) account for cell dimensions in the discretization and 2) apply any user-defined weighting. This is equivalent to an objective function of the form:
\[\phi (\mathbf{m}) = \Big \| \mathbf{W} \big [ \mathbf{m} - \mathbf{m}^{(ref)} \big ] \Big \|^2\]where
\(\mathbf{m}^{(ref)}\) is a reference model (set using reference_model), and
\(\mathbf{W}\) is the weighting matrix.
Custom weights and the weighting matrix:
Let \(\mathbf{w_1, \; w_2, \; w_3, \; ...}\) each represent an optional set of custom cell weights. The weighting applied within the objective function is given by:
\[\mathbf{\tilde{w}} = \mathbf{v} \odot \prod_j \mathbf{w_j}\]where \(\mathbf{v}\) are the cell volumes. The weighting matrix used to apply the weights for smallness regularization is given by:
\[\mathbf{W} = \textrm{diag} \Big ( \, \mathbf{\tilde{w}}^{1/2} \Big )\]Each set of custom cell weights is stored within a
dict
as an (n_cells, )numpy.ndarray
. The weights can be set all at once during instantiation with the weights keyword argument as follows:>>> reg = Smallness(mesh, weights={'weights_1': array_1, 'weights_2': array_2})
or set after instantiation using the set_weights method:
>>> reg.set_weights(weights_1=array_1, weights_2=array_2)
The default weights that account for cell dimensions in the regularization are accessed via:
>>> reg.get_weights('volume')
Attributes
Weighting matrix.
Active cells defined on the regularization mesh.
Deprecated property for 'volume' and user defined weights.
active_cells.indActive has been deprecated.
Mapping from the inversion model parameters to the regularization mesh.
The model parameters.
reference_model.mref has been deprecated.
Number of model parameters.
The parent objective function
Reference model.
regularization_mesh.regmesh has been deprecated.
Regularization mesh.
Units for the model parameters.
Return the keys for the existing cell weights
Methods
__call__
(m)Evaluate the regularization function for the model provided.
deriv
(m)Gradient of the regularization function evaluated for the model provided.
deriv2
(m[, v])Hessian of the regularization function evaluated for the model provided.
f_m
(m)Evaluate the regularization kernel function.
f_m_deriv
(m)Derivative of the regularization kernel function.
get_weights
(key)Cell weights for a given key.
map_class
alias of
IdentityMap
remove_weights
(key)Removes the weights for the key provided.
set_weights
(**weights)Adds (or updates) the specified weights to the regularization.
test
([x, num])Run a convergence test on both the first and second derivatives.
Galleries and Tutorials using SimPEG.regularization.Smallness
#
Method of Equivalent Sources for Removing VRM Responses