def test_11(self):
N = 63
M = 4
Nd = 8
D = np.random.randn(Nd, Nd, M)
X0 = np.zeros((N, N, M))
xr = np.random.randn(N, N, M)
xp = np.abs(xr) > 3
X0[xp] = np.random.randn(X0[xp].size)
S = np.sum(ifftn(
fftn(D, (N, N), (0, 1)) * fftn(X0, None, (0, 1)), None,
(0, 1)).real,
axis=2)
lmbda = 1e-4
rho = 1e-1
opt = cbpdn.ConvBPDN.Options({
'Verbose': False,
'MaxMainIter': 500,
'RelStopTol': 1e-3,
'rho': rho,
'AutoRho': {
'Enabled': False
}
})
b = cbpdn.ConvBPDN(D, S, lmbda, opt)
b.solve()
X1 = b.Y.squeeze()
assert rrs(X0, X1) < 5e-5
Sr = b.reconstruct().squeeze()
assert rrs(S, Sr) < 1e-4
def test_11(self):
N = 63
M = 4
Nd = 8
D = np.random.randn(Nd, Nd, M)
X0 = np.zeros((N, N, M))
xr = np.random.randn(N, N, M)
xp = np.abs(xr) > 3
X0[xp] = np.random.randn(X0[xp].size)
S = np.sum(ifftn(
fftn(D, (N, N), (0, 1)) * fftn(X0, None, (0, 1)), None,
(0, 1)).real,
axis=2)
lmbda = 1e-2
L = 1e3
opt = cbpdn.ConvBPDN.Options({
'Verbose': False,
'MaxMainIter': 2000,
'RelStopTol': 1e-9,
'L': L,
'Backtrack': BacktrackStandard()
})
b = cbpdn.ConvBPDN(D, S, lmbda, opt)
b.solve()
X1 = b.X.squeeze()
assert sl.rrs(X0, X1) < 5e-4
Sr = b.reconstruct().squeeze()
assert sl.rrs(S, Sr) < 2e-4
def test_18(self):
N = 64
M = 4
Nd = 8
D0 = cr.normalise(cr.zeromean(np.random.randn(Nd, Nd, M), (Nd, Nd, M),
dimN=2),
dimN=2)
X = np.zeros((N, N, M))
xr = np.random.randn(N, N, M)
xp = np.abs(xr) > 3
X[xp] = np.random.randn(X[xp].size)
S = np.sum(ifftn(
fftn(D0, (N, N), (0, 1)) * fftn(X, None, (0, 1)), None,
(0, 1)).real,
axis=2)
L = 50.0
opt = ccmod.ConvCnstrMOD.Options({
'Verbose': False,
'MaxMainIter': 3000,
'ZeroMean': True,
'RelStopTol': 0.,
'L': L,
'Monotone': True
})
Xr = X.reshape(X.shape[0:2] + (
1,
1,
) + X.shape[2:])
Sr = S.reshape(S.shape + (1, ))
c = ccmod.ConvCnstrMOD(Xr, Sr, D0.shape, opt)
c.solve()
D1 = cr.bcrop(c.X, D0.shape).squeeze()
assert rrs(D0, D1) < 1e-4
assert np.array(c.getitstat().Rsdl)[-1] < 1e-5
def test_02(self):
N = 32
M = 4
Nd = 5
D0 = cr.normalise(cr.zeromean(
np.random.randn(Nd, Nd, M), (Nd, Nd, M), dimN=2), dimN=2)
X = np.zeros((N, N, M))
xr = np.random.randn(N, N, M)
xp = np.abs(xr) > 3
X[xp] = np.random.randn(X[xp].size)
S = np.sum(ifftn(fftn(D0, (N, N), (0, 1)) *
fftn(X, None, (0, 1)), None, (0, 1)).real, axis=2)
rho = 1e-1
opt = ccmod.ConvCnstrMOD_CG.Options({'Verbose': False,
'MaxMainIter': 500, 'LinSolveCheck': True,
'ZeroMean': True, 'RelStopTol': 1e-5, 'rho': rho,
'AutoRho': {'Enabled': False},
'CG': {'StopTol': 1e-5}})
Xr = X.reshape(X.shape[0:2] + (1, 1,) + X.shape[2:])
Sr = S.reshape(S.shape + (1,))
c = ccmod.ConvCnstrMOD_CG(Xr, Sr, D0.shape, opt)
c.solve()
D1 = cr.bcrop(c.Y, D0.shape).squeeze()
assert rrs(D0, D1) < 1e-4
assert np.array(c.getitstat().XSlvRelRes).max() < 1e-3
def xstep(self):
r"""Minimise Augmented Lagrangian with respect to
:math:`\mathbf{x}`."""
self.YU[:] = self.Y - self.U
b = self.DSf + self.rho * fftn(self.YU, None, self.cri.axisN)
if self.cri.Cd == 1:
self.Xf[:] = sl.solvedbi_sm(self.Df, self.rho, b, self.c,
self.cri.axisM)
else:
self.Xf[:] = sl.solvemdbi_ism(self.Df, self.rho, b, self.cri.axisM,
self.cri.axisC)
self.X = ifftn(self.Xf, self.cri.Nv, self.cri.axisN)
if self.opt['LinSolveCheck']:
Dop = lambda x: sl.inner(self.Df, x, axis=self.cri.axisM)
if self.cri.Cd == 1:
DHop = lambda x: np.conj(self.Df) * x
else:
DHop = lambda x: sl.inner(np.conj(self.Df), x,
axis=self.cri.axisC)
ax = DHop(Dop(self.Xf)) + self.rho * self.Xf
self.xrrs = sl.rrs(ax, b)
else:
self.xrrs = None
def obfn_fvarf(self):
"""Variable to be evaluated in computing data fidelity term,
depending on ``fEvalX`` option value.
"""
return self.Xf if self.opt['fEvalX'] else \
fftn(self.Y, None, self.cri.axisN)
def reconstruct(self, X=None):
"""Reconstruct representation."""
if X is None:
X = self.Y
Xf = fftn(X, None, self.cri.axisN)
Sf = np.sum(self.Df * Xf, axis=self.cri.axisM)
return ifftn(Sf, self.cri.Nv, self.cri.axisN)
def obfn_fvarf(self):
"""Variable to be evaluated in computing data fidelity term,
depending on 'fEvalX' option value.
"""
if self.opt['fEvalX']:
return self.swapaxes(self.Xf)
else:
return fftn(self.Y, None, self.cri.axisN)
def xstep(self):
r"""Minimise Augmented Lagrangian with respect to :math:`\mathbf{x}`.
"""
self.YU[:] = self.Y - self.U
b = self.ZSf + self.rho * fftn(self.YU, None, self.cri.axisN)
self.Xf[:] = sl.solvemdbi_ism(self.Zf, self.rho, b, self.cri.axisM,
self.cri.axisK)
self.X = ifftn(self.Xf, self.cri.Nv, self.cri.axisN)
self.xstep_check(b)
def reconstruct(self, D=None):
"""Reconstruct representation."""
if D is None:
Df = self.Xf
else:
Df = fftn(D, None, self.cri.axisN)
Sf = np.sum(self.Zf * Df, axis=self.cri.axisM)
return ifftn(Sf, self.cri.Nv, self.cri.axisN)
def __init__(self, D, S, opt=None, dimK=None, dimN=2):
"""
This class supports an arbitrary number of spatial dimensions,
`dimN`, with a default of 2. The input dictionary `D` is either
`dimN` + 1 dimensional, in which case each spatial component
(image in the default case) is assumed to consist of a single
channel, or `dimN` + 2 dimensional, in which case the final
dimension is assumed to contain the channels (e.g. colour
channels in the case of images). The input signal set `S` is
either `dimN` dimensional (no channels, only one signal),
`dimN` + 1 dimensional (either multiple channels or multiple
signals), or `dimN` + 2 dimensional (multiple channels and
multiple signals). Determination of problem dimensions is
handled by :class:`.cnvrep.CSC_ConvRepIndexing`.
Parameters
----------
D : array_like
Dictionary array
S : array_like
Signal array
opt : :class:`GenericConvBPDN.Options` object
Algorithm options
dimK : 0, 1, or None, optional (default None)
Number of dimensions in input signal corresponding to multiple
independent signals
dimN : int, optional (default 2)
Number of spatial/temporal dimensions
"""
# Set default options if none specified
if opt is None:
opt = ComplexGenericConvBPDN.Options()
# Infer problem dimensions and set relevant attributes of self
if not hasattr(self, 'cri'):
self.cri = cr.CSC_ConvRepIndexing(D, S, dimK=dimK, dimN=dimN)
# Call parent class __init__
super(ComplexGenericConvBPDN, self).__init__(self.cri.shpX, S.dtype, opt)
# Reshape D and S to standard layout
self.D = np.asarray(D.reshape(self.cri.shpD), dtype=self.dtype)
self.S = np.asarray(S.reshape(self.cri.shpS), dtype=self.dtype)
# Compute signal in complex DFT domain
self.Sf = fftn(self.S, None, self.cri.axisN)
# Initialise byte-aligned arrays for pyfftw
self.YU = empty_aligned(self.Y.shape, dtype=self.dtype)
self.Xf = empty_aligned(self.Y.shape, dtype=self.dtype)
self.setdict()
def xistep(self, i):
r"""Minimise Augmented Lagrangian with respect to :math:`\mathbf{x}`
component :math:`\mathbf{x}_i`.
"""
self.YU[:] = self.Y - self.U[..., i]
b = np.take(self.ZSf, [i], axis=self.cri.axisK) + \
self.rho*fftn(self.YU, None, self.cri.axisN)
self.Xf[..., i] = sl.solvedbi_sm(np.take(self.Zf, [i],
axis=self.cri.axisK),
self.rho,
b,
axis=self.cri.axisM)
self.X[..., i] = ifftn(self.Xf[..., i], self.cri.Nv, self.cri.axisN)
def xstep(self):
r"""Minimise Augmented Lagrangian with respect to block vector
:math:`\mathbf{x} = \left( \begin{array}{ccc} \mathbf{x}_0^T &
\mathbf{x}_1^T & \ldots \end{array} \right)^T\;`.
"""
# This test reflects empirical evidence that two slightly
# different implementations are faster for single or
# multi-channel data. This kludge is intended to be temporary.
if self.cri.Cd > 1:
for i in range(self.Nb):
self.xistep(i)
else:
self.YU[:] = self.Y[..., np.newaxis] - self.U
b = np.swapaxes(self.ZSf[..., np.newaxis], self.cri.axisK, -1) \
+ self.rho*fftn(self.YU, None, self.cri.axisN)
for i in range(self.Nb):
self.Xf[..., i] = sl.solvedbi_sm(self.Zf[..., [i], :],
self.rho,
b[..., i],
axis=self.cri.axisM)
self.X = ifftn(self.Xf, self.cri.Nv, self.cri.axisN)
if self.opt['LinSolveCheck']:
ZSfs = np.sum(self.ZSf, axis=self.cri.axisK, keepdims=True)
YU = np.sum(self.Y[..., np.newaxis] - self.U, axis=-1)
b = ZSfs + self.rho * fftn(YU, None, self.cri.axisN)
Xf = self.swapaxes(self.Xf)
Zop = lambda x: sl.inner(self.Zf, x, axis=self.cri.axisM)
ZHop = lambda x: np.conj(self.Zf) * x
ax = np.sum(ZHop(Zop(Xf)) + self.rho * Xf,
axis=self.cri.axisK,
keepdims=True)
self.xrrs = sl.rrs(ax, b)
else:
self.xrrs = None
def setdict(self, D=None):
"""Set dictionary array."""
if D is not None:
self.D = np.asarray(D, dtype=self.dtype)
self.Df = fftn(self.D, self.cri.Nv, self.cri.axisN)
# Compute D^H S
self.DSf = np.conj(self.Df) * self.Sf
if self.cri.Cd > 1:
self.DSf = np.sum(self.DSf, axis=self.cri.axisC, keepdims=True)
if self.opt['HighMemSolve'] and self.cri.Cd == 1:
self.c = sl.solvedbi_sm_c(self.Df, np.conj(self.Df), self.rho,
self.cri.axisM)
else:
self.c = None
def setcoef(self, Z):
"""Set coefficient array."""
# If the dictionary has a single channel but the input (and
# therefore also the coefficient map array) has multiple
# channels, the channel index and multiple image index have
# the same behaviour in the dictionary update equation: the
# simplest way to handle this is to just reshape so that the
# channels also appear on the multiple image index.
if self.cri.Cd == 1 and self.cri.C > 1:
Z = Z.reshape(self.cri.Nv + (1, ) + (self.cri.Cx * self.cri.K, ) +
(self.cri.M, ))
self.Z = np.asarray(Z, dtype=self.dtype)
self.Zf = fftn(self.Z, self.cri.Nv, self.cri.axisN)
# Compute X^H S
self.ZSf = np.conj(self.Zf) * self.Sf
def gradient_filters(ndim, axes, axshp, dtype=None):
r"""Construct a set of filters for computing gradients in the
frequency domain.
Parameters
----------
ndim : integer
Total number of dimensions in array in which gradients are to be
computed
axes : tuple of integers
Axes on which gradients are to be computed
axshp : tuple of integers
Shape of axes on which gradients are to be computed
dtype : dtype, optional (default np.float32)
Data type of output arrays
Returns
-------
Gf : ndarray
Frequency domain gradient operators :math:`\hat{G}_i`
GHGf : ndarray
Sum of products :math:`\sum_i \hat{G}_i^H \hat{G}_i`
"""
if dtype is None:
dtype = np.float32
g = np.zeros([2 if k in axes else 1 for k in range(ndim)] + [
len(axes),
], dtype)
for k in axes:
g[(0,) * k + (slice(None),) + (0,) * (g.ndim - 2 - k) + (k,)] = \
np.array([1, -1])
if is_complex_dtype(dtype):
Gf = fftn(g, axshp, axes=axes)
else:
Gf = rfftn(g, axshp, axes=axes)
GHGf = np.sum(np.conj(Gf) * Gf, axis=-1).real
return Gf, GHGf
def test_01(self):
x = np.random.randn(16, 8)
xf = fft.fftn(x, axes=(0, ))
n1 = np.linalg.norm(x)**2
n2 = fft.fl2norm2(xf, axis=(0, ))
assert np.abs(n1 - n2) < 1e-12
def __init__(self, D, S, lmbda=None, opt=None, dimK=None, dimN=2):
"""
This class supports an arbitrary number of spatial dimensions,
`dimN`, with a default of 2. The input dictionary `D` is either
`dimN` + 1 dimensional, in which case each spatial component
(image in the default case) is assumed to consist of a single
channel, or `dimN` + 2 dimensional, in which case the final
dimension is assumed to contain the channels (e.g. colour
channels in the case of images). The input signal set `S` is
either `dimN` dimensional (no channels, only one signal), `dimN`
+ 1 dimensional (either multiple channels or multiple signals),
or `dimN` + 2 dimensional (multiple channels and multiple
signals). Determination of problem dimensions is handled by
:class:`.cnvrep.CSC_ConvRepIndexing`.
|
**Call graph**
.. image:: ../_static/jonga/cbpdn_init.svg
:width: 20%
:target: ../_static/jonga/cbpdn_init.svg
|
Parameters
----------
D : array_like
Dictionary array
S : array_like
Signal array
lmbda : float
Regularisation parameter
opt : :class:`ConvBPDN.Options` object
Algorithm options
dimK : 0, 1, or None, optional (default None)
Number of dimensions in input signal corresponding to multiple
independent signals
dimN : int, optional (default 2)
Number of spatial/temporal dimensions
"""
# Set default options if none specified
if opt is None:
opt = ComplexConvBPDN.Options()
# Set dtype attribute based on S.dtype and opt['DataType']
self.set_dtype(opt, S.dtype)
# Set default lambda value if not specified
if lmbda is None:
cri = cr.CSC_ConvRepIndexing(D, S, dimK=dimK, dimN=dimN)
Df = fftn(D.reshape(cri.shpD), cri.Nv, axes=cri.axisN)
Sf = fftn(S.reshape(cri.shpS), axes=cri.axisN)
b = np.conj(Df) * Sf
lmbda = 0.1 * abs(b).max()
# Set l1 term scaling
self.lmbda = self.dtype.type(lmbda)
# Set penalty parameter
self.set_attr('rho', opt['rho'], dval=(50.0 * self.lmbda + 1.0),
dtype=self.dtype)
# Set rho_xi attribute (see Sec. VI.C of wohlberg-2015-adaptive)
if self.lmbda != 0.0:
# rho_xi = float((1.0 + (18.3)**(np.log10(self.lmbda) + 1.0)))
rho_xi = (1.0 + (18.3) ** (np.log10(self.lmbda) + 1.0))
else:
rho_xi = 1.0
self.set_attr('rho_xi', opt['AutoRho', 'RsdlTarget'], dval=rho_xi,
dtype=self.dtype)
# Call parent class __init__
super(ComplexConvBPDN, self).__init__(D, S, opt, dimK, dimN)
# Set l1 term weight array
self.wl1 = np.asarray(opt['L1Weight'], dtype=self.dtype)
self.wl1 = self.wl1.reshape(cr.l1Wshape(self.wl1, self.cri))
def __init__(self, Z, S, dsz, opt=None, dimK=1, dimN=2):
"""
This class supports an arbitrary number of spatial dimensions,
`dimN`, with a default of 2. The input coefficient map array `Z`
(usually labelled X, but renamed here to avoid confusion with
the X and Y variables in the ADMM base class) is expected to
be in standard form as computed by the ConvBPDN class.
The input signal set `S` is either `dimN` dimensional (no
channels, only one signal), `dimN` +1 dimensional (either
multiple channels or multiple signals), or `dimN` +2 dimensional
(multiple channels and multiple signals). Parameter `dimK`, with
a default value of 1, indicates the number of multiple-signal
dimensions in `S`:
::
Default dimK = 1, i.e. assume input S is of form
S(N0, N1, C, K) or S(N0, N1, K)
If dimK = 0 then input S is of form
S(N0, N1, C, K) or S(N0, N1, C)
The internal data layout for S, D (X here), and X (Z here) is:
::
dim<0> - dim<Nds-1> : Spatial dimensions, product of N0,N1,... is N
dim<Nds> : C number of channels in S and D
dim<Nds+1> : K number of signals in S
dim<Nds+2> : M number of filters in D
sptl. chn sig flt
S(N0, N1, C, K, 1)
D(N0, N1, C, 1, M) (X here)
X(N0, N1, 1, K, M) (Z here)
The `dsz` parameter indicates the desired filter supports in the
output dictionary, since this cannot be inferred from the
input variables. The format is the same as the `dsz` parameter
of :func:`.cnvrep.bcrop`.
Parameters
----------
Z : array_like
Coefficient map array
S : array_like
Signal array
dsz : tuple
Filter support size(s)
opt : ccmod.Options object
Algorithm options
dimK : int, optional (default 1)
Number of dimensions for multiple signals in input S
dimN : int, optional (default 2)
Number of spatial dimensions
"""
# Set default options if none specified
if opt is None:
opt = ComConvCnstrMODBase.Options()
# Infer problem dimensions and set relevant attributes of self
self.cri = cr.CDU_ConvRepIndexing(dsz, S, dimK=dimK, dimN=dimN)
# Call parent class __init__
super(ComConvCnstrMODBase, self).__init__(self.cri.shpD, S.dtype, opt)
# Set penalty parameter
self.set_attr('rho', opt['rho'], dval=self.cri.K, dtype=self.dtype)
# Reshape S to standard layout (Z, i.e. X in cbpdn, is assumed
# to be taken from cbpdn, and therefore already in standard
# form). If the dictionary has a single channel but the input
# (and therefore also the coefficient map array) has multiple
# channels, the channel index and multiple image index have
# the same behaviour in the dictionary update equation: the
# simplest way to handle this is to just reshape so that the
# channels also appear on the multiple image index.
if self.cri.Cd == 1 and self.cri.C > 1:
self.S = S.reshape(self.cri.Nv + (1, ) +
(self.cri.C * self.cri.K, ) + (1, ))
else:
self.S = S.reshape(self.cri.shpS)
self.S = np.asarray(self.S, dtype=self.dtype)
# Compute signal S in DFT domain
self.Sf = fftn(self.S, None, self.cri.axisN)
# Create constraint set projection function
self.Pcn = cr.getPcn(dsz,
self.cri.Nv,
self.cri.dimN,
self.cri.dimCd,
zm=opt['ZeroMean'])
# Create byte aligned arrays for FFT calls
self.YU = empty_aligned(self.Y.shape, dtype=self.dtype)
self.Xf = empty_aligned(self.Y.shape, dtype=self.dtype)
if Z is not None:
self.setcoef(Z)
def __init__(self, Z, S, dsz, opt=None, dimK=1, dimN=2):
"""
|
**Call graph**
.. image:: ../_static/jonga/ccmodcnsns_init.svg
:width: 20%
:target: ../_static/jonga/ccmodcnsns_init.svg
"""
# Set default options if none specified
if opt is None:
opt = ComConvCnstrMOD_Consensus.Options()
# Infer problem dimensions and set relevant attributes of self
self.cri = cr.CDU_ConvRepIndexing(dsz, S, dimK=dimK, dimN=dimN)
# Handle possible reshape of channel axis onto multiple image axis
# (see comment below)
Nb = self.cri.K if self.cri.C == self.cri.Cd else \
self.cri.C * self.cri.K
admm.ADMMConsensus.__init__(self, Nb, self.cri.shpD, S.dtype, opt)
# Set penalty parameter
self.set_attr('rho', opt['rho'], dval=self.cri.K, dtype=self.dtype)
# Reshape S to standard layout (Z, i.e. X in cbpdn, is assumed
# to be taken from cbpdn, and therefore already in standard
# form). If the dictionary has a single channel but the input
# (and therefore also the coefficient map array) has multiple
# channels, the channel index and multiple image index have
# the same behaviour in the dictionary update equation: the
# simplest way to handle this is to just reshape so that the
# channels also appear on the multiple image index.
if self.cri.Cd == 1 and self.cri.C > 1:
self.S = S.reshape(self.cri.Nv + (1, ) +
(self.cri.C * self.cri.K, ) + (1, ))
else:
self.S = S.reshape(self.cri.shpS)
self.S = np.asarray(self.S, dtype=self.dtype)
# Compute signal S in DFT domain
self.Sf = fftn(self.S, None, self.cri.axisN)
# Create constraint set projection function
self.Pcn = cr.getPcn(dsz,
self.cri.Nv,
self.cri.dimN,
self.cri.dimCd,
zm=opt['ZeroMean'])
if Z is not None:
self.setcoef(Z)
self.X = empty_aligned(self.xshape, dtype=self.dtype)
# See comment on corresponding test in xstep method
if self.cri.Cd > 1:
self.YU = empty_aligned(self.yshape, dtype=self.dtype)
else:
self.YU = empty_aligned(self.xshape, dtype=self.dtype)
self.Xf = empty_aligned(self.xshape, dtype=self.dtype)
