def test_PreconditionedInversion(par):
"""Solve regularized inversion in least squares sense
"""
np.random.seed(10)
G = np.random.normal(0, 10, (par['ny'], par['nx'])).astype('float32') + \
par['imag']*np.random.normal(0, 10,
(par['ny'], par['nx'])).astype('float32')
Gop = MatrixMult(G, dtype=par['dtype'])
Pre = Smoothing1D(nsmooth=5, dims=[par['nx']], dtype=par['dtype'])
p = np.ones(par['nx']) + par['imag']*np.ones(par['nx'])
x = Pre*p
x0 = np.random.normal(0, 1, par['nx']) + \
par['imag']*np.random.normal(0, 1, par['nx']) if par['x0'] else None
y = Gop*x
xinv = PreconditionedInversion(Gop, Pre, y, x0=x0,
returninfo=False,
**dict(damp=0, iter_lim=800, show=0))
assert_array_almost_equal(x, xinv, decimal=2)
def MDD(
G,
d,
dt=0.004,
dr=1.0,
nfmax=None,
wav=None,
twosided=True,
causality_precond=False,
adjoint=False,
psf=False,
dtype="float64",
dottest=False,
saveGt=True,
add_negative=True,
smooth_precond=0,
fftengine="numpy",
**kwargs_solver
):
r"""Multi-dimensional deconvolution.
Solve multi-dimensional deconvolution problem using
:py:func:`scipy.sparse.linalg.lsqr` iterative solver.
Parameters
----------
G : :obj:`numpy.ndarray`
Multi-dimensional convolution kernel in time domain of size
:math:`[n_s \times n_r \times n_t]` for ``twosided=False`` or
``twosided=True`` and ``add_negative=True``
(with only positive times) or size
:math:`[n_s \times n_r \times 2n_t-1]` for ``twosided=True`` and
``add_negative=False``
(with both positive and negative times)
d : :obj:`numpy.ndarray`
Data in time domain :math:`[n_s \,(\times n_{vs}) \times n_t]` if
``twosided=False`` or ``twosided=True`` and ``add_negative=True``
(with only positive times) or size
:math:`[n_s \,(\times n_{vs}) \times 2n_t-1]` if ``twosided=True``
dt : :obj:`float`, optional
Sampling of time integration axis
dr : :obj:`float`, optional
Sampling of receiver integration axis
nfmax : :obj:`int`, optional
Index of max frequency to include in deconvolution process
wav : :obj:`numpy.ndarray`, optional
Wavelet to convolve to the inverted model and psf
(must be centered around its index in the middle of the array).
If ``None``, the outputs of the inversion are returned directly.
twosided : :obj:`bool`, optional
MDC operator and data both negative and positive time (``True``)
or only positive (``False``)
add_negative : :obj:`bool`, optional
Add negative side to MDC operator and data (``True``) or not
(``False``)- operator and data are already provided with both positive
and negative sides. To be used only with ``twosided=True``.
causality_precond : :obj:`bool`, optional
Apply causality mask (``True``) or not (``False``)
smooth_precond : :obj:`int`, optional
Lenght of smoothing to apply to causality preconditioner
adjoint : :obj:`bool`, optional
Compute and return adjoint(s)
psf : :obj:`bool`, optional
Compute and return Point Spread Function (PSF) and its inverse
dtype : :obj:`bool`, optional
Type of elements in input array.
dottest : :obj:`bool`, optional
Apply dot-test
saveGt : :obj:`bool`, optional
Save ``G`` and ``G.H`` to speed up the computation of adjoint of
:class:`pylops.signalprocessing.Fredholm1` (``True``) or create
``G.H`` on-the-fly (``False``) Note that ``saveGt=True`` will be
faster but double the amount of required memory
fftengine : :obj:`str`, optional
Engine used for fft computation (``numpy``, ``scipy`` or ``fftw``)
**kwargs_solver
Arbitrary keyword arguments for chosen solver
(:py:func:`scipy.sparse.linalg.cg` and
:py:func:`pylops.optimization.solver.cg` are used as default for numpy
and cupy `data`, respectively)
Returns
-------
minv : :obj:`numpy.ndarray`
Inverted model of size :math:`[n_r \,(\times n_{vs}) \times n_t]`
for ``twosided=False`` or
:math:`[n_r \,(\times n_vs) \times 2n_t-1]` for ``twosided=True``
madj : :obj:`numpy.ndarray`
Adjoint model of size :math:`[n_r \,(\times n_{vs}) \times n_t]`
for ``twosided=False`` or
:math:`[n_r \,(\times n_r) \times 2n_t-1]` for ``twosided=True``
psfinv : :obj:`numpy.ndarray`
Inverted psf of size :math:`[n_r \times n_r \times n_t]`
for ``twosided=False`` or
:math:`[n_r \times n_r \times 2n_t-1]` for ``twosided=True``
psfadj : :obj:`numpy.ndarray`
Adjoint psf of size :math:`[n_r \times n_r \times n_t]`
for ``twosided=False`` or
:math:`[n_r \times n_r \times 2n_t-1]` for ``twosided=True``
See Also
--------
MDC : Multi-dimensional convolution
Notes
-----
Multi-dimensional deconvolution (MDD) is a mathematical ill-solved problem,
well-known in the image processing and geophysical community [1]_.
MDD aims at removing the effects of a Multi-dimensional Convolution
(MDC) kernel or the so-called blurring operator or point-spread
function (PSF) from a given data. It can be written as
.. math::
\mathbf{d}= \mathbf{D} \mathbf{m}
or, equivalently, by means of its normal equation
.. math::
\mathbf{m}= (\mathbf{D}^H\mathbf{D})^{-1} \mathbf{D}^H\mathbf{d}
where :math:`\mathbf{D}^H\mathbf{D}` is the PSF.
.. [1] Wapenaar, K., van der Neut, J., Ruigrok, E., Draganov, D., Hunziker,
J., Slob, E., Thorbecke, J., and Snieder, R., "Seismic interferometry
by crosscorrelation and by multi-dimensional deconvolution: a
systematic comparison", Geophyscial Journal International, vol. 185,
pp. 1335-1364. 2011.
"""
ncp = get_array_module(d)
ns, nr, nt = G.shape
if len(d.shape) == 2:
nv = 1
else:
nv = d.shape[1]
if twosided:
if add_negative:
nt2 = 2 * nt - 1
else:
nt2 = nt
nt = (nt2 + 1) // 2
nfmax_allowed = int(np.ceil((nt2 + 1) / 2))
else:
nt2 = nt
nfmax_allowed = nt
# Fix nfmax to be at maximum equal to half of the size of fft samples
if nfmax is None or nfmax > nfmax_allowed:
nfmax = nfmax_allowed
logging.warning("nfmax set equal to ceil[(nt+1)/2=%d]" % nfmax)
# Add negative part to data and model
if twosided and add_negative:
G = np.concatenate((ncp.zeros((ns, nr, nt - 1)), G), axis=-1)
d = np.concatenate((np.squeeze(np.zeros((ns, nv, nt - 1))), d), axis=-1)
# Bring kernel to frequency domain
Gfft = np.fft.rfft(G, nt2, axis=-1)
Gfft = Gfft[..., :nfmax]
# Bring frequency/time to first dimension
Gfft = np.moveaxis(Gfft, -1, 0)
d = np.moveaxis(d, -1, 0)
if psf:
G = np.moveaxis(G, -1, 0)
# Define MDC linear operator
MDCop = MDC(
Gfft,
nt2,
nv=nv,
dt=dt,
dr=dr,
twosided=twosided,
transpose=False,
saveGt=saveGt,
fftengine=fftengine,
)
if psf:
PSFop = MDC(
Gfft,
nt2,
nv=nr,
dt=dt,
dr=dr,
twosided=twosided,
transpose=False,
saveGt=saveGt,
fftengine=fftengine,
)
if dottest:
Dottest(
MDCop, nt2 * ns * nv, nt2 * nr * nv, verb=True, backend=get_module_name(ncp)
)
if psf:
Dottest(
PSFop,
nt2 * ns * nr,
nt2 * nr * nr,
verb=True,
backend=get_module_name(ncp),
)
# Adjoint
if adjoint:
madj = MDCop.H * d.ravel()
madj = np.squeeze(madj.reshape(nt2, nr, nv))
madj = np.moveaxis(madj, 0, -1)
if psf:
psfadj = PSFop.H * G.ravel()
psfadj = np.squeeze(psfadj.reshape(nt2, nr, nr))
psfadj = np.moveaxis(psfadj, 0, -1)
# Inverse
if twosided and causality_precond:
P = np.ones((nt2, nr, nv))
P[: nt - 1] = 0
if smooth_precond > 0:
P = filtfilt(np.ones(smooth_precond) / smooth_precond, 1, P, axis=0)
P = to_cupy_conditional(d, P)
Pop = Diagonal(P)
minv = PreconditionedInversion(
MDCop, Pop, d.ravel(), returninfo=False, **kwargs_solver
)
else:
if ncp == np and "callback" not in kwargs_solver:
minv = lsqr(MDCop, d.ravel(), **kwargs_solver)[0]
else:
minv = cgls(
MDCop,
d.ravel(),
ncp.zeros(int(MDCop.shape[1]), dtype=MDCop.dtype),
**kwargs_solver
)[0]
minv = np.squeeze(minv.reshape(nt2, nr, nv))
minv = np.moveaxis(minv, 0, -1)
if wav is not None:
wav1 = wav.copy()
for _ in range(minv.ndim - 1):
wav1 = wav1[ncp.newaxis]
minv = get_fftconvolve(d)(minv, wav1, mode="same")
if psf:
if ncp == np:
psfinv = lsqr(PSFop, G.ravel(), **kwargs_solver)[0]
else:
psfinv = cgls(
PSFop,
G.ravel(),
ncp.zeros(int(PSFop.shape[1]), dtype=PSFop.dtype),
**kwargs_solver
)[0]
psfinv = np.squeeze(psfinv.reshape(nt2, nr, nr))
psfinv = np.moveaxis(psfinv, 0, -1)
if wav is not None:
wav1 = wav.copy()
for _ in range(psfinv.ndim - 1):
wav1 = wav1[np.newaxis]
psfinv = get_fftconvolve(d)(psfinv, wav1, mode="same")
if adjoint and psf:
return minv, madj, psfinv, psfadj
elif adjoint:
return minv, madj
elif psf:
return minv, psfinv
else:
return minv
def MDD(G,
d,
dt=0.004,
dr=1.,
nfmax=None,
wav=None,
twosided=True,
causality_precond=False,
adjoint=False,
psf=False,
dtype='complex64',
dottest=False,
**kwargs_lsqr):
r"""Multi-dimensional deconvolution.
Solve multi-dimensional deconvolution problem using :py:func:`scipy.sparse.linalg.lsqr`
iterative solver.
Parameters
----------
G : :obj:`numpy.ndarray`
Multi-dimensional convolution kernel in frequency domain of size
:math:`[n_s \times n_r \times n_{fmax}]`
d : :obj:`numpy.ndarray`
Data in time domain :math:`[ns (\times nr) \times nt]`
dt : :obj:`float`, optional
Sampling of time integration axis
dr : :obj:`float`, optional
Sampling of receiver integration axis
nfmax : :obj:`int`, optional
Index of max frequency to include in deconvolution process
twosided : :obj:`bool`, optional
MDC operator has both negative and positive time (``True``)
or only positive (``False``)
causality_precond : :obj:`bool`, optional
Apply causality mask (``True``) or not (``False``)
adjoint : :obj:`bool`, optional
Compute and return adjoint(s)
psf : :obj:`bool`, optional
Compute and return Point Spread Function (PSF) and its inverse
dtype : :obj:`bool`, optional
Type of elements in input array.
dottest : :obj:`bool`, optional
Apply dot-test
**kwargs_lsqr
Arbitrary keyword arguments for :py:func:`scipy.sparse.linalg.lsqr` solver
Returns
----------
minv : :obj:`numpy.ndarray`
Inverted model.
madj : :obj:`numpy.ndarray`
Adjoint model.
psfinv : :obj:`numpy.ndarray`
Inverted psf.
psfadj : :obj:`numpy.ndarray`
Adjoint psf.
See Also
--------
MDC : Multi-dimensional convolution
Notes
-----
Multi-dimensional deconvolution (MDD) is a mathematical ill-solved problem,
well-known in the image processing and geophysical community [1]_.
MDD aims at removing the effects of a Multi-dimensional Convolution (MDC) kernel
or the so-called blurring operator or point-spread function (PSF) from a given data.
It can be written as
.. math::
\mathbf{d}= \mathbf{D} \mathbf{m}
or, equivalently, by means of its normal equation
.. math::
\mathbf{m}= (\mathbf{D}^H\mathbf{D})^{-1} \mathbf{D}^H\mathbf{d}
where :math:`\mathbf{D}^H\mathbf{D}` is the PSF.
.. [1] Wapenaar, K., van der Neut, J., Ruigrok, E., Draganov, D., Hunziker, J.,
Slob, E., Thorbecke, J., and Snieder, R., "Seismic interferometry by crosscorrelation
and by multi-dimensional deconvolution: a systematic comparison",
Geophyscial Journal International, vol. 185, pp. 1335-1364. 2011.
"""
ns, nr, nt = G.shape
if len(d.shape) == 2:
ns, nt = d.shape
nv = 1
else:
ns, nv, nt = d.shape
nt2 = nt if twosided == False else 2 * nt - 1
# Fix nfmax to be at maximum equal to half of the size of fft samples
if nfmax == None or nfmax > np.ceil((nt2 + 1) / 2):
nfmax = int(np.ceil((nt2 + 1) / 2))
logging.warning('nfmax set equal to (nt+1)/2=%d' % nfmax)
# Add negative part to data and model
if twosided:
G = np.concatenate((np.zeros((ns, nr, nt - 1)), G), axis=-1)
d = np.concatenate((np.squeeze(np.zeros((ns, nv, nt - 1))), d),
axis=-1)
# Define MDC linear operator
Gfft = np.fft.rfft(G, nt2, axis=-1)
Gfft = Gfft[..., :nfmax]
MDCop = MDC(Gfft, nt2, nv=nv, dt=dt, dr=dr, twosided=twosided, dtype=dtype)
if psf:
PSFop = MDC(Gfft,
nt2,
nv=nr,
dt=dt,
dr=dr,
twosided=twosided,
dtype=dtype)
if dottest:
Dottest(MDCop, nt2 * ns * nv, nt2 * nr * nv, verb=True)
if psf:
Dottest(PSFop, nt2 * ns * nr, nt2 * nr * nr, verb=True)
# Adjoint
if adjoint:
madj = MDCop.H * d.flatten()
madj = np.squeeze(madj.reshape(nr, nv, nt2))
if psf:
psfadj = PSFop.H * G.flatten()
psfadj = np.squeeze(psfadj.reshape(nr, nr, nt2))
# Inverse
if twosided and causality_precond:
P = np.ones((nr, nv, nt2))
P[:, :, :nt - 1] = 0
Pop = Diagonal(P)
minv = PreconditionedInversion(MDCop,
Pop,
d.flatten(),
returninfo=False,
**kwargs_lsqr)
else:
minv = lsqr(MDCop, d.flatten(), **kwargs_lsqr)[0]
minv = np.squeeze(minv.reshape(nr, nv, nt2))
if wav is not None:
minv = sp_convolve1d(minv, wav, axis=-1)
if psf:
psfinv = lsqr(PSFop, G.flatten(), **kwargs_lsqr)[0]
psfinv = np.squeeze(psfinv.reshape(nr, nr, nt2))
if wav is not None:
psfinv = sp_convolve1d(psfinv, wav, axis=-1)
if adjoint and psf:
return minv, madj, psfinv, psfadj
elif adjoint:
return minv, madj
elif psf:
return minv, psfinv
else:
return minv