def solve(self, S, W=None, dimK=None):
"""Compute sparse coding and dictionary update for training
data `S`."""
# Use dimK specified in __init__ as default
if dimK is None and self.dimK is not None:
dimK = self.dimK
# Start solve timer
self.timer.start(['solve', 'solve_wo_eval'])
# Solve CSC problem on S and do dictionary step
self.init_vars(S, dimK)
if W is None:
W = np.array([1.0], dtype=self.dtype)
W = np.asarray(W.reshape(cr.mskWshape(W, self.cri)), dtype=self.dtype)
self.xstep(S, W, self.lmbda, dimK)
self.dstep(W)
# Stop solve timer
self.timer.stop('solve_wo_eval')
# Extract and record iteration stats
self.manage_itstat()
# Increment iteration count
self.j += 1
# Stop solve timer
self.timer.stop('solve')
# Return current dictionary
return self.getdict()
def __init__(self, D, S, lmbda, W=None, opt=None, dimK=None, dimN=2):
"""Assume the signal S has already been masked by W."""
if opt is None:
opt = ConvBPDNSliceMaskDcpl.Options()
super().__init__(D, S, lmbda, opt, dimK=dimK, dimN=dimN)
if W is None:
self.W = np.array([1.0], dtype=self.dtype)
else:
self.W = np.asarray(W.reshape(cr.mskWshape(W, self.cri)),
dtype=self.dtype)
self.W = self.W.squeeze(-1).transpose((3, 2, 0, 1))
def test_08(self):
N = 32
M = 16
L = 8
dsz = (L, L, M)
S = np.random.randn(N, N)
cri = cnvrep.CDU_ConvRepIndexing(dsz, S, dimK=0)
assert cri.M == M
assert cri.K == 1
assert cri.Nv == (N, N)
assert str(cri) != ''
W = np.random.randn(N, N)
assert cnvrep.mskWshape(W, cri) == (N, N, 1, 1, 1)
def test_08(self):
N = 32
M = 16
L = 8
dsz = (L, L, M)
S = np.random.randn(N, N)
cri = cnvrep.CDU_ConvRepIndexing(dsz, S, dimK=0)
assert cri.M == M
assert cri.K == 1
assert cri.Nv == (N, N)
assert str(cri) != ''
W = np.random.randn(N, N)
assert cnvrep.mskWshape(W, cri) == (N, N, 1, 1, 1)
def __init__(self, D, S, lmbda, W=None, opt=None, dimK=None, dimN=2):
"""Initialise a ConvBPDNMask object with problem parameters.
|
Parameters
----------
D : array_like
Dictionary matrix
S : array_like
Signal vector or matrix
lmbda : float
Regularisation parameter
W : array_like
Mask array. The array shape must be such that the array is
compatible for multiplication with input array S (see
:func:`.cnvrep.mskWshape` for more details).
opt : :class:`ConvBPDNMask.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 dimensions
"""
super(ConvBPDNMask, self).__init__(D,
S,
lmbda,
opt,
dimK=dimK,
dimN=dimN)
# Set gradient step parameter
#self.set_attr('L', opt['L'], dval=100.0, dtype=self.dtype)
if W is None:
W = np.array([1.0], dtype=self.dtype)
self.W = np.asarray(W.reshape(cr.mskWshape(W, self.cri)),
dtype=self.dtype)
# Create byte aligned arrays for FFT calls
self.WRy = sl.pyfftw_empty_aligned(self.S.shape, dtype=self.dtype)
self.Ryf = sl.pyfftw_rfftn_empty_aligned(self.S.shape, self.cri.axisN,
self.dtype)
def __init__(self, D, S, lmbda, W=None, opt=None, dimK=None, dimN=2):
"""
|
Parameters
----------
D : array_like
Dictionary matrix
S : array_like
Signal vector or matrix
lmbda : float
Regularisation parameter
W : array_like
Mask array. The array shape must be such that the array is
compatible for multiplication with input array S (see
:func:`.cnvrep.mskWshape` for more details).
opt : :class:`ConvBPDNMask.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 dimensions
"""
super(ConvBPDNMask, self).__init__(D, S, lmbda, opt, dimK=dimK,
dimN=dimN)
if W is None:
W = np.array([1.0], dtype=self.dtype)
self.W = np.asarray(W.reshape(cr.mskWshape(W, self.cri)),
dtype=self.dtype)
# Create byte aligned arrays for FFT calls
self.WRy = sl.pyfftw_empty_aligned(self.S.shape, dtype=self.dtype)
self.Ryf = sl.pyfftw_rfftn_empty_aligned(self.S.shape, self.cri.axisN,
self.dtype)
def __init__(self, D, S, lmbda=None, W=None, opt=None, nproc=None,
ngrp=None, dimK=None, dimN=2):
"""
Parameters
----------
D : array_like
Dictionary matrix
S : array_like
Signal vector or matrix
lmbda : float
Regularisation parameter
W : array_like
Mask array. The array shape must be such that the array is
compatible for multiplication with input array S (see
:func:`.cnvrep.mskWshape` for more details).
opt : :class:`ParConvBPDN.Options` object
Algorithm options
nproc : int
Number of processes
ngrp : int
Number of groups in partition of filter indices
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 dimensions
"""
self.pool = None
# Set default options if none specified
if opt is None:
opt = ParConvBPDN.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 = sl.rfftn(D.reshape(cri.shpD), cri.Nv, axes=cri.axisN)
Sf = sl.rfftn(S.reshape(cri.shpS), axes=cri.axisN)
b = np.conj(Df) * Sf
lmbda = 0.1*abs(b).max()
# Set l1 term scaling and weight array
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)
self.set_attr('alpha', opt['alpha'], dval=1.0,
dtype=self.dtype)
# Set rho_xi attribute (see Sec. VI.C of wohlberg-2015-adaptive)
# if self.lmbda != 0.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(ParConvBPDN, self).__init__(D, S, opt, dimK, dimN)
if nproc is None:
if ngrp is None:
self.nproc = min(mp.cpu_count(), self.cri.M)
self.ngrp = self.nproc
else:
self.nproc = min(mp.cpu_count(), ngrp, self.cri.M)
self.ngrp = ngrp
else:
if ngrp is None:
self.ngrp = nproc
self.nproc = nproc
else:
self.ngrp = ngrp
self.nproc = nproc
if W is None:
W = np.array([1.0], dtype=self.dtype)
self.W = np.asarray(W.reshape(cr.mskWshape(W, self.cri)),
dtype=self.dtype)
self.wl1 = np.asarray(opt['L1Weight'], dtype=self.dtype)
self.wl1 = self.wl1.reshape(cr.l1Wshape(self.wl1, self.cri))
self.xrrs = None
# Initialise global variables
# Conv Rep Indexing and parameter values for multiprocessing
global mp_nproc
mp_nproc = self.nproc
global mp_ngrp
mp_ngrp = self.ngrp
global mp_Nv
mp_Nv = self.cri.Nv
global mp_axisN
mp_axisN = tuple(i+1 for i in self.cri.axisN)
global mp_C
mp_C = self.cri.C
global mp_Cd
mp_Cd = self.cri.Cd
global mp_axisC
mp_axisC = self.cri.axisC+1
global mp_axisM
mp_axisM = 0
global mp_NonNegCoef
mp_NonNegCoef = self.opt['NonNegCoef']
global mp_NoBndryCross
mp_NoBndryCross = self.opt['NoBndryCross']
global mp_Dshp
mp_Dshp = self.D.shape
# Parameters for optimization
global mp_lmbda
mp_lmbda = self.lmbda
global mp_rho
mp_rho = self.rho
global mp_alpha
mp_alpha = self.alpha
global mp_rlx
mp_rlx = self.rlx
global mp_wl1
init_mpraw('mp_wl1', np.moveaxis(self.wl1, self.cri.axisM, mp_axisM))
# Matrices used in optimization
global mp_S
init_mpraw('mp_S', np.moveaxis(self.S*self.W**2, self.cri.axisM,
mp_axisM))
global mp_Df
init_mpraw('mp_Df', np.moveaxis(self.Df, self.cri.axisM, mp_axisM))
global mp_X
init_mpraw('mp_X', np.moveaxis(self.Y, self.cri.axisM, mp_axisM))
shp_X = list(mp_X.shape)
global mp_Xnr
mp_Xnr = mpraw_as_np(mp_X.shape, mp_X.dtype)
global mp_Y0
shp_Y0 = shp_X[:]
shp_Y0[0] = self.ngrp
shp_Y0[mp_axisC] = mp_C
if self.opt['Y0'] is not None:
init_mpraw('Y0', np.moveaxis(
self.opt['Y0'].astype(self.dtype, copy=True),
self.cri.axisM, mp_axisM))
else:
mp_Y0 = mpraw_as_np(shp_Y0, mp_X.dtype)
global mp_Y0old
mp_Y0old = mpraw_as_np(shp_Y0, mp_X.dtype)
global mp_Y1
if self.opt['Y1'] is not None:
init_mpraw('Y1', np.moveaxis(
self.opt['Y1'].astype(self.dtype, copy=True),
self.cri.axisM, mp_axisM))
else:
mp_Y1 = mpraw_as_np(shp_X, mp_X.dtype)
global mp_Y1old
mp_Y1old = mpraw_as_np(shp_X, mp_X.dtype)
global mp_U0
if self.opt['U0'] is not None:
init_mpraw('U0', np.moveaxis(
self.opt['U0'].astype(self.dtype, copy=True),
self.cri.axisM, mp_axisM))
else:
mp_U0 = mpraw_as_np(shp_Y0, mp_X.dtype)
global mp_U1
if self.opt['U1'] is not None:
init_mpraw('U1', np.moveaxis(
self.opt['U1'].astype(self.dtype, copy=True),
self.cri.axisM, mp_axisM))
else:
mp_U1 = mpraw_as_np(shp_X, mp_X.dtype)
global mp_DX
mp_DX = mpraw_as_np(shp_Y0, mp_X.dtype)
global mp_DXnr
mp_DXnr = mpraw_as_np(shp_Y0, mp_X.dtype)
# Variables used to solve the optimization efficiently
global mp_inv_off_diag
if self.W.ndim is self.cri.axisM+1:
init_mpraw('mp_inv_off_diag', np.moveaxis(
-self.W**2/(mp_rho*(mp_rho+self.W**2*mp_ngrp)),
self.cri.axisM, mp_axisM))
else:
init_mpraw('mp_inv_off_diag',
-self.W**2/(mp_rho*(mp_rho+self.W**2*mp_ngrp)))
global mp_grp
mp_grp = [np.min(i) for i in
np.array_split(np.array(range(self.cri.M)),
mp_ngrp)] + [self.cri.M, ]
global mp_cache
if self.opt['HighMemSolve'] and self.cri.Cd == 1:
mp_cache = [sl.solvedbi_sm_c(mp_Df[k], np.conj(mp_Df[k]),
mp_alpha**2, mp_axisM) for k in
np.array_split(np.array(range(self.cri.M)), self.ngrp)]
else:
mp_cache = [None for k in mp_grp]
global mp_b
shp_b = shp_Y0[:]
shp_b[0] = 1
mp_b = mpraw_as_np(shp_b, mp_X.dtype)
# Residual and stopping criteria variables
global mp_ry0
mp_ry0 = mpraw_as_np((self.ngrp,), mp_X.dtype)
global mp_ry1
mp_ry1 = mpraw_as_np((self.ngrp,), mp_X.dtype)
global mp_sy0
mp_sy0 = mpraw_as_np((self.ngrp,), mp_X.dtype)
global mp_sy1
mp_sy1 = mpraw_as_np((self.ngrp,), mp_X.dtype)
global mp_nrmAx
mp_nrmAx = mpraw_as_np((self.ngrp,), mp_X.dtype)
global mp_nrmBy
mp_nrmBy = mpraw_as_np((self.ngrp,), mp_X.dtype)
global mp_nrmu
mp_nrmu = mpraw_as_np((self.ngrp,), mp_X.dtype)
def __init__(self, Z, S, W, dsz, opt=None, dimK=None, dimN=2):
"""
Initialise a ConvCnstrMODMaskDcpl_Consensus object with problem
size and options.
|
**Call graph**
.. image:: _static/jonga/ccmodmdcnsns_init.svg
:width: 20%
:target: _static/jonga/ccmodmdcnsns_init.svg
|
Parameters
----------
Z : array_like
Coefficient map array
S : array_like
Signal array
W : array_like
Mask array. The array shape must be such that the array is
compatible for multiplication with input array S (see
:func:`.cnvrep.mskWshape` for more details).
dsz : tuple
Filter support size(s)
opt : :class:`.ConvCnstrMOD_Consensus.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 dimensions
"""
# Set default options if none specified
if opt is None:
opt = ccmod.ConvCnstrMOD_Consensus.Options()
super(ConvCnstrMODMaskDcpl_Consensus, self).__init__(Z,
S,
dsz,
opt=opt,
dimK=dimK,
dimN=dimN)
# Convert W to internal shape
W = np.asarray(W.reshape(cr.mskWshape(W, self.cri)), dtype=S.dtype)
# Reshape W if necessary (see discussion of reshape of S in
# ccmod.ConvCnstrMOD_Consensus.__init__)
if self.cri.Cd == 1 and self.cri.C > 1:
# In most cases broadcasting rules make it possible for W
# to have a singleton dimension corresponding to a non-singleton
# dimension in S. However, when S is reshaped to interleave axisC
# and axisK on the same axis, broadcasting is no longer sufficient
# unless axisC and axisK of W are either both singleton or both
# of the same size as the corresponding axes of S. If neither of
# these cases holds, it is necessary to replicate the axis of W
# (axisC or axisK) that does not have the same size as the
# corresponding axis of S.
shpw = list(W.shape)
swck = shpw[self.cri.axisC] * shpw[self.cri.axisK]
if swck > 1 and swck < self.cri.C * self.cri.K:
if W.shape[self.cri.axisK] == 1 and self.cri.K > 1:
shpw[self.cri.axisK] = self.cri.K
else:
shpw[self.cri.axisC] = self.cri.C
W = np.broadcast_to(W, shpw)
self.W = W.reshape(W.shape[0:self.cri.dimN] +
(1, W.shape[self.cri.axisC] *
W.shape[self.cri.axisK], 1))
self.W = W.reshape(W.shape[0:self.cri.dimN] +
(1, W.shape[self.cri.axisC] *
W.shape[self.cri.axisK], 1))
else:
self.W = W
# Initialise additional variables required for the different
# splitting used in combining the consensus solution with mask
# decoupling
self.Y1 = np.zeros(self.S.shape, dtype=self.dtype)
self.U1 = np.zeros(self.S.shape, dtype=self.dtype)
self.YU1 = sl.pyfftw_empty_aligned(self.S.shape, dtype=self.dtype)
def __init__(self, Z, S, W, dsz, opt=None, dimK=None, dimN=2):
"""
Initialise a ConvCnstrMODMaskDcplBase object with problem size
and options.
Parameters
----------
Z : array_like
Coefficient map array
S : array_like
Signal array
W : array_like
Mask array. The array shape must be such that the array is
compatible for multiplication with input array S (see
:func:`.cnvrep.mskWshape` for more details).
dsz : tuple
Filter support size(s)
opt : :class:`ConvCnstrMODMaskDcplBase.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 dimensions
"""
# Set default options if none specified
if opt is None:
opt = ConvCnstrMODMaskDcplBase.Options()
# Infer problem dimensions and set relevant attributes of self
self.cri = cr.CDU_ConvRepIndexing(dsz, S, dimK=dimK, dimN=dimN)
# Convert W to internal shape
W = np.asarray(W.reshape(cr.mskWshape(W, self.cri)), dtype=S.dtype)
# Reshape W if necessary (see discussion of reshape of S below)
if self.cri.Cd == 1 and self.cri.C > 1:
# In most cases broadcasting rules make it possible for W
# to have a singleton dimension corresponding to a non-singleton
# dimension in S. However, when S is reshaped to interleave axisC
# and axisK on the same axis, broadcasting is no longer sufficient
# unless axisC and axisK of W are either both singleton or both
# of the same size as the corresponding axes of S. If neither of
# these cases holds, it is necessary to replicate the axis of W
# (axisC or axisK) that does not have the same size as the
# corresponding axis of S.
shpw = list(W.shape)
swck = shpw[self.cri.axisC] * shpw[self.cri.axisK]
if swck > 1 and swck < self.cri.C * self.cri.K:
if W.shape[self.cri.axisK] == 1 and self.cri.K > 1:
shpw[self.cri.axisK] = self.cri.K
else:
shpw[self.cri.axisC] = self.cri.C
W = np.broadcast_to(W, shpw)
self.W = W.reshape(W.shape[0:self.cri.dimN] +
(1, W.shape[self.cri.axisC] *
W.shape[self.cri.axisK], 1))
else:
self.W = W
# Call parent class __init__
Nx = self.cri.N * self.cri.Cd * self.cri.M
CK = (self.cri.C if self.cri.Cd == 1 else 1) * self.cri.K
shpY = list(self.cri.shpX)
shpY[self.cri.axisC] = self.cri.Cd
shpY[self.cri.axisK] = 1
shpY[self.cri.axisM] += CK
super(ConvCnstrMODMaskDcplBase,
self).__init__(Nx, shpY, self.cri.axisM, CK, S.dtype, opt)
# 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)
# Create constraint set projection function
self.Pcn = cr.getPcn(dsz,
self.cri.Nv,
self.cri.dimN,
self.cri.dimCd,
zm=opt['ZeroMean'])
# Initialise byte-aligned arrays for pyfftw
self.YU = sl.pyfftw_empty_aligned(self.Y.shape, dtype=self.dtype)
xfshp = list(self.cri.Nv + (self.cri.Cd, 1, self.cri.M))
xfshp[dimN - 1] = xfshp[dimN - 1] // 2 + 1
self.Xf = sl.pyfftw_empty_aligned(xfshp,
dtype=sl.complex_dtype(self.dtype))
if Z is not None:
self.setcoef(Z)
def __init__(self, D, S, lmbda=None, W=None, opt=None, nproc=None,
ngrp=None, dimK=None, dimN=2):
"""
Parameters
----------
D : array_like
Dictionary matrix
S : array_like
Signal vector or matrix
lmbda : float
Regularisation parameter
W : array_like
Mask array. The array shape must be such that the array is
compatible for multiplication with input array S (see
:func:`.cnvrep.mskWshape` for more details).
opt : :class:`ParConvBPDN.Options` object
Algorithm options
nproc : int
Number of processes
ngrp : int
Number of groups in partition of filter indices
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 dimensions
"""
self.pool = None
# Set default options if none specified
if opt is None:
opt = ParConvBPDN.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 = sl.rfftn(D.reshape(cri.shpD), cri.Nv, axes=cri.axisN)
Sf = sl.rfftn(S.reshape(cri.shpS), axes=cri.axisN)
b = np.conj(Df) * Sf
lmbda = 0.1*abs(b).max()
# Set l1 term scaling and weight array
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)
self.set_attr('alpha', opt['alpha'], dval=1.0,
dtype=self.dtype)
# Set rho_xi attribute (see Sec. VI.C of wohlberg-2015-adaptive)
# if self.lmbda != 0.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(ParConvBPDN, self).__init__(D, S, opt, dimK, dimN)
if nproc is None:
if ngrp is None:
self.nproc = min(mp.cpu_count(), self.cri.M)
self.ngrp = self.nproc
else:
self.nproc = min(mp.cpu_count(), ngrp, self.cri.M)
self.ngrp = ngrp
else:
if ngrp is None:
self.ngrp = nproc
self.nproc = nproc
else:
self.ngrp = ngrp
self.nproc = nproc
if W is None:
W = np.array([1.0], dtype=self.dtype)
self.W = np.asarray(W.reshape(cr.mskWshape(W, self.cri)),
dtype=self.dtype)
self.wl1 = np.asarray(opt['L1Weight'], dtype=self.dtype)
self.wl1 = self.wl1.reshape(cr.l1Wshape(self.wl1, self.cri))
self.xrrs = None
# Initialise global variables
# Conv Rep Indexing and parameter values for multiprocessing
global mp_nproc
mp_nproc = self.nproc
global mp_ngrp
mp_ngrp = self.ngrp
global mp_Nv
mp_Nv = self.cri.Nv
global mp_axisN
mp_axisN = tuple(i+1 for i in self.cri.axisN)
global mp_C
mp_C = self.cri.C
global mp_Cd
mp_Cd = self.cri.Cd
global mp_axisC
mp_axisC = self.cri.axisC+1
global mp_axisM
mp_axisM = 0
global mp_NonNegCoef
mp_NonNegCoef = self.opt['NonNegCoef']
global mp_NoBndryCross
mp_NoBndryCross = self.opt['NoBndryCross']
global mp_Dshp
mp_Dshp = self.D.shape
# Parameters for optimization
global mp_lmbda
mp_lmbda = self.lmbda
global mp_rho
mp_rho = self.rho
global mp_alpha
mp_alpha = self.alpha
global mp_rlx
mp_rlx = self.rlx
global mp_wl1
init_mpraw('mp_wl1', np.moveaxis(self.wl1, self.cri.axisM, mp_axisM))
# Matrices used in optimization
global mp_S
init_mpraw('mp_S', np.moveaxis(self.S*self.W**2, self.cri.axisM,
mp_axisM))
global mp_Df
init_mpraw('mp_Df', np.moveaxis(self.Df, self.cri.axisM, mp_axisM))
global mp_X
init_mpraw('mp_X', np.moveaxis(self.Y, self.cri.axisM, mp_axisM))
shp_X = list(mp_X.shape)
global mp_Xnr
mp_Xnr = mpraw_as_np(mp_X.shape, mp_X.dtype)
global mp_Y0
shp_Y0 = shp_X[:]
shp_Y0[0] = self.ngrp
shp_Y0[mp_axisC] = mp_C
if self.opt['Y0'] is not None:
init_mpraw('Y0', np.moveaxis(
self.opt['Y0'].astype(self.dtype, copy=True),
self.cri.axisM, mp_axisM))
else:
mp_Y0 = mpraw_as_np(shp_Y0, mp_X.dtype)
global mp_Y0old
mp_Y0old = mpraw_as_np(shp_Y0, mp_X.dtype)
global mp_Y1
if self.opt['Y1'] is not None:
init_mpraw('Y1', np.moveaxis(
self.opt['Y1'].astype(self.dtype, copy=True),
self.cri.axisM, mp_axisM))
else:
mp_Y1 = mpraw_as_np(shp_X, mp_X.dtype)
global mp_Y1old
mp_Y1old = mpraw_as_np(shp_X, mp_X.dtype)
global mp_U0
if self.opt['U0'] is not None:
init_mpraw('U0', np.moveaxis(
self.opt['U0'].astype(self.dtype, copy=True),
self.cri.axisM, mp_axisM))
else:
mp_U0 = mpraw_as_np(shp_Y0, mp_X.dtype)
global mp_U1
if self.opt['U1'] is not None:
init_mpraw('U1', np.moveaxis(
self.opt['U1'].astype(self.dtype, copy=True),
self.cri.axisM, mp_axisM))
else:
mp_U1 = mpraw_as_np(shp_X, mp_X.dtype)
global mp_DX
mp_DX = mpraw_as_np(shp_Y0, mp_X.dtype)
global mp_DXnr
mp_DXnr = mpraw_as_np(shp_Y0, mp_X.dtype)
# Variables used to solve the optimization efficiently
global mp_inv_off_diag
if self.W.ndim is self.cri.axisM+1:
init_mpraw('mp_inv_off_diag', np.moveaxis(
-self.W**2/(mp_rho*(mp_rho+self.W**2*mp_ngrp)),
self.cri.axisM, mp_axisM))
else:
init_mpraw('mp_inv_off_diag',
-self.W**2/(mp_rho*(mp_rho+self.W**2*mp_ngrp)))
global mp_grp
mp_grp = [np.min(i) for i in
np.array_split(np.array(range(self.cri.M)),
mp_ngrp)] + [self.cri.M, ]
global mp_cache
if self.opt['HighMemSolve'] and self.cri.Cd == 1:
mp_cache = [sl.solvedbi_sm_c(mp_Df[k], np.conj(mp_Df[k]),
mp_alpha**2, mp_axisM) for k in
np.array_split(np.array(range(self.cri.M)), self.ngrp)]
else:
mp_cache = [None for k in mp_grp]
global mp_b
shp_b = shp_Y0[:]
shp_b[0] = 1
mp_b = mpraw_as_np(shp_b, mp_X.dtype)
# Residual and stopping criteria variables
global mp_ry0
mp_ry0 = mpraw_as_np((self.ngrp,), mp_X.dtype)
global mp_ry1
mp_ry1 = mpraw_as_np((self.ngrp,), mp_X.dtype)
global mp_sy0
mp_sy0 = mpraw_as_np((self.ngrp,), mp_X.dtype)
global mp_sy1
mp_sy1 = mpraw_as_np((self.ngrp,), mp_X.dtype)
global mp_nrmAx
mp_nrmAx = mpraw_as_np((self.ngrp,), mp_X.dtype)
global mp_nrmBy
mp_nrmBy = mpraw_as_np((self.ngrp,), mp_X.dtype)
global mp_nrmu
mp_nrmu = mpraw_as_np((self.ngrp,), mp_X.dtype)
def __init__(self, Z, S, W, dsz, opt=None, dimK=None, dimN=2):
"""
|
**Call graph**
.. image:: ../_static/jonga/ccmodmdcnsns_init.svg
:width: 20%
:target: ../_static/jonga/ccmodmdcnsns_init.svg
|
Parameters
----------
Z : array_like
Coefficient map array
S : array_like
Signal array
W : array_like
Mask array. The array shape must be such that the array is
compatible for multiplication with input array S (see
:func:`.cnvrep.mskWshape` for more details).
dsz : tuple
Filter support size(s)
opt : :class:`.ConvCnstrMOD_Consensus.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 dimensions
"""
# Set default options if none specified
if opt is None:
opt = ccmod.ConvCnstrMOD_Consensus.Options()
super(ConvCnstrMODMaskDcpl_Consensus, self).__init__(
Z, S, dsz, opt=opt, dimK=dimK, dimN=dimN)
# Convert W to internal shape
if W is None:
W = np.array([1.0], dtype=self.dtype)
W = np.asarray(W.reshape(cr.mskWshape(W, self.cri)),
dtype=S.dtype)
# Reshape W if necessary (see discussion of reshape of S in
# ccmod.ConvCnstrMOD_Consensus.__init__)
if self.cri.Cd == 1 and self.cri.C > 1:
# In most cases broadcasting rules make it possible for W
# to have a singleton dimension corresponding to a non-singleton
# dimension in S. However, when S is reshaped to interleave axisC
# and axisK on the same axis, broadcasting is no longer sufficient
# unless axisC and axisK of W are either both singleton or both
# of the same size as the corresponding axes of S. If neither of
# these cases holds, it is necessary to replicate the axis of W
# (axisC or axisK) that does not have the same size as the
# corresponding axis of S.
shpw = list(W.shape)
swck = shpw[self.cri.axisC] * shpw[self.cri.axisK]
if swck > 1 and swck < self.cri.C * self.cri.K:
if W.shape[self.cri.axisK] == 1 and self.cri.K > 1:
shpw[self.cri.axisK] = self.cri.K
else:
shpw[self.cri.axisC] = self.cri.C
W = np.broadcast_to(W, shpw)
self.W = W.reshape(
W.shape[0:self.cri.dimN] +
(1, W.shape[self.cri.axisC] * W.shape[self.cri.axisK], 1))
else:
self.W = W
# Initialise additional variables required for the different
# splitting used in combining the consensus solution with mask
# decoupling
self.Y1 = np.zeros(self.S.shape, dtype=self.dtype)
self.U1 = np.zeros(self.S.shape, dtype=self.dtype)
self.YU1 = sl.pyfftw_empty_aligned(self.S.shape, dtype=self.dtype)
def __init__(self, Z, S, W, dsz, opt=None, dimK=None, dimN=2):
"""
Parameters
----------
Z : array_like
Coefficient map array
S : array_like
Signal array
W : array_like
Mask array. The array shape must be such that the array is
compatible for multiplication with input array S (see
:func:`.cnvrep.mskWshape` for more details).
dsz : tuple
Filter support size(s)
opt : :class:`ConvCnstrMODMaskDcplBase.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 dimensions
"""
# Set default options if none specified
if opt is None:
opt = ConvCnstrMODMaskDcplBase.Options()
# Infer problem dimensions and set relevant attributes of self
self.cri = cr.CDU_ConvRepIndexing(dsz, S, dimK=dimK, dimN=dimN)
# Convert W to internal shape
W = np.asarray(W.reshape(cr.mskWshape(W, self.cri)),
dtype=S.dtype)
# Reshape W if necessary (see discussion of reshape of S below)
if self.cri.Cd == 1 and self.cri.C > 1:
# In most cases broadcasting rules make it possible for W
# to have a singleton dimension corresponding to a non-singleton
# dimension in S. However, when S is reshaped to interleave axisC
# and axisK on the same axis, broadcasting is no longer sufficient
# unless axisC and axisK of W are either both singleton or both
# of the same size as the corresponding axes of S. If neither of
# these cases holds, it is necessary to replicate the axis of W
# (axisC or axisK) that does not have the same size as the
# corresponding axis of S.
shpw = list(W.shape)
swck = shpw[self.cri.axisC] * shpw[self.cri.axisK]
if swck > 1 and swck < self.cri.C * self.cri.K:
if W.shape[self.cri.axisK] == 1 and self.cri.K > 1:
shpw[self.cri.axisK] = self.cri.K
else:
shpw[self.cri.axisC] = self.cri.C
W = np.broadcast_to(W, shpw)
self.W = W.reshape(
W.shape[0:self.cri.dimN] +
(1, W.shape[self.cri.axisC] * W.shape[self.cri.axisK], 1))
else:
self.W = W
# Call parent class __init__
Nx = self.cri.N * self.cri.Cd * self.cri.M
CK = (self.cri.C if self.cri.Cd == 1 else 1) * self.cri.K
shpY = list(self.cri.shpX)
shpY[self.cri.axisC] = self.cri.Cd
shpY[self.cri.axisK] = 1
shpY[self.cri.axisM] += CK
super(ConvCnstrMODMaskDcplBase, self).__init__(
Nx, shpY, self.cri.axisM, CK, S.dtype, opt)
# 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)
# Create constraint set projection function
self.Pcn = cr.getPcn(dsz, self.cri.Nv, self.cri.dimN, self.cri.dimCd,
zm=opt['ZeroMean'])
# Initialise byte-aligned arrays for pyfftw
self.YU = sl.pyfftw_empty_aligned(self.Y.shape, dtype=self.dtype)
xfshp = list(self.cri.Nv + (self.cri.Cd, 1, self.cri.M))
self.Xf = sl.pyfftw_rfftn_empty_aligned(xfshp, self.cri.axisN,
self.dtype)
if Z is not None:
self.setcoef(Z)
