Regularization is model styling |
Formalizing now our wish
that data be extractable by linear interpolation ,
from a model ,
and our wish that application of a roughening filter
with an operator have minimum energy, we write the fitting goals:
The residual vector has two parts, a data part on top and a model part on the bottom. The data residual should vanish except where contradictory data values happen to lie in the same place. The model residual is the roughened model.
Finding something unexpected is good science and engineering. We should look both in data space and model space. In data space, we look at the residual . In model space, we look at the residual projected there . After iterating to completion, we have , a sum of two images identical but for polarity. This image tells us what we have learned from the data; and how the model differs from what we thought it would be.
After all the definitions,
we load the negative of the data into the residual.
If a starting model is present,
then we update the data part of the residual
,
and we load
the model part of the residual
.
Otherwise, we begin from a zero model
; and thus,
the model part of the residual is also zero.
After this initialization, subroutine
solver_reg() begins an iteration loop by first computing
the proposed model perturbation
(called g in the program)
with the adjoint operator:
(16) |
(17) |
An example of using the new solver is subroutine invint1. I chose to implement the model roughening operator with the convolution subroutine tcai1() which has transient end effects (and an output length equal to the input length plus the filter length). The adjoint of subroutine tcai1() suggests perturbations in the convolution input (not the filter).
void invint1(int niter /* number of iterations */, int nd /* data size */, float *coord /* data coordinates */, const float *dd /* data values */, int n1, float o1, float d1 /* model grid */, int na, const float *aa /* filter */, float *mm /* estimated model */, float eps /* regularization */) /*< inverse interpolation >*/ { lint1_init( o1, d1, coord); /* interpolation */ tcai1_init( na, aa); /* filtering */ sf_solver_reg(lint1_lop, sf_cgstep, tcai1_lop, n1+na, n1, nd, mm, dd, niter, eps); sf_cgstep_close( ); } |
Figure 11 shows an example for a filter with . The continuous curve representing the model passes through the data points. Because the models are computed with transient convolution end-effects, the models tend to damp linearly to zero outside the region where signal samples are given.
im1-2+1
Figure 11. Sample points and estimation of a continuous function through them. | |
---|---|
To show an example where the result is clearly a theoretical answer, I prepared another figure with the simpler filter . When we minimize energy in the first derivative of the waveform, the residual becomes distributed uniformly between data points so the solution there is a straight line. Theoretically, it should be a straight line, because a straight line has a vanishing second derivative; and that condition arises by differentiating by , the minimized quadratic form , and getting . (By this logic, the curves between data points in Figure 11 must be cubics.) The result is shown in Figure 12.
im1-1a
Figure 12. The same data samples and a function through them that minimizes the energy in the first derivative. | |
---|---|
The example of Figure 12 has been a useful test case for me. You will see it again in later chapters. What I would like to show you here is a movie showing the convergence to Figure 12. Convergence occurs rapidly where data points are close together. The large gaps, however, fill at a rate of one point per iteration.
Regularization is model styling |