def iteration_stats(self):
"""Construct iteration stats record tuple."""
tk = self.timer.elapsed(self.opt['IterTimer'])
if self.xstep_itstat is None:
objfn = (0.0, ) * 3
rsdl = (0.0, ) * 2
rho = (0.0, )
else:
objfn = (self.xstep_itstat.ObjFun, self.xstep_itstat.DFid,
self.xstep_itstat.RegL1)
rsdl = (self.xstep_itstat.PrimalRsdl, self.xstep_itstat.DualRsdl)
rho = (self.xstep_itstat.Rho, )
cnstr = np.linalg.norm(cr.zpad(self.D, self.cri.Nv) - self.G)
dltd = np.linalg.norm(self.D - self.Dprv)
tpl = (self.j,) + objfn + rsdl + rho + (cnstr, dltd, self.eta) + \
self.itstat_extra() + (tk,)
return type(self).IterationStats(*tpl)
method='ism')
"""
Normalise dictionary according to dictionary Y update options.
"""
D0n = cnvrep.Pcn(D0, D0.shape, cri.Nv, dimN=2, dimC=0, crp=True,
zm=optd['ZeroMean'])
"""
Update D update options to include initial values for Y and U.
"""
optd.update({'Y0': cnvrep.zpad(cnvrep.stdformD(D0n, cri.Cd, cri.M), cri.Nv),
'U0': np.zeros(cri.shpD)})
"""
Create X update object.
"""
xstep = cbpdn.ConvBPDNJoint(D0n, sh, lmbda, mu, optx)
"""
Create D update object.
"""
dstep = ccmod.ConvCnstrMOD(None, sh, D0.shape, optd, method='ism')
def __init__(self,
D0,
S,
lmbda,
W,
opt=None,
xmethod=None,
dmethod=None,
dimK=1,
dimN=2):
"""
|
**Call graph**
.. image:: ../_static/jonga/cbpdnmddl_init.svg
:width: 20%
:target: ../_static/jonga/cbpdnmddl_init.svg
|
Parameters
----------
D0 : array_like
Initial dictionary array
S : array_like
Signal array
lmbda : float
Regularisation parameter
W : array_like
Mask array. The array shape must be such that the array is
compatible for multiplication with the *internal* shape of
input array S (see :class:`.cnvrep.CDU_ConvRepIndexing` for a
discussion of the distinction between *external* and *internal*
data layouts) after reshaping to the shape determined by
:func:`.cnvrep.mskWshape`.
opt : :class:`ConvBPDNMaskDictLearn.Options` object
Algorithm options
xmethod : string, optional (default 'admm')
String selecting sparse coding solver. Valid values are
documented in function :func:`.ConvBPDNMask`.
dmethod : string, optional (default 'pgm')
String selecting dictionary update solver. Valid values are
documented in function :func:`.ConvCnstrMODMask`.
dimK : int, optional (default 1)
Number of signal dimensions. If there is only a single input
signal (e.g. if `S` is a 2D array representing a single image)
`dimK` must be set to 0.
dimN : int, optional (default 2)
Number of spatial/temporal dimensions
"""
if opt is None:
opt = ConvBPDNMaskDictLearn.Options(xmethod=xmethod,
dmethod=dmethod)
if xmethod is None:
xmethod = opt.xmethod
if dmethod is None:
dmethod = opt.dmethod
if opt.xmethod != xmethod or opt.dmethod != dmethod:
raise ValueError('Parameters xmethod and dmethod must have the '
'same values used to initialise the Options '
'object')
self.opt = opt
self.xmethod = xmethod
self.dmethod = dmethod
# Get dictionary size
if self.opt['DictSize'] is None:
dsz = D0.shape
else:
dsz = self.opt['DictSize']
# Construct object representing problem dimensions
cri = cr.CDU_ConvRepIndexing(dsz, S, dimK, dimN)
# Normalise dictionary
D0 = cr.Pcn(D0,
dsz,
cri.Nv,
dimN,
cri.dimCd,
crp=True,
zm=opt['CCMOD', 'ZeroMean'])
# Modify D update options to include initial values for Y
if cri.C == cri.Cd:
Y0b0 = np.zeros(cri.Nv + (cri.C, 1, cri.K))
else:
Y0b0 = np.zeros(cri.Nv + (1, 1, cri.C * cri.K))
Y0b1 = cr.zpad(cr.stdformD(D0, cri.Cd, cri.M, dimN), cri.Nv)
if dmethod == 'pgm':
opt['CCMOD'].update({'X0': Y0b1})
else:
if dmethod == 'cns':
Y0 = Y0b1
else:
Y0 = np.concatenate((Y0b0, Y0b1), axis=cri.axisM)
opt['CCMOD'].update({'Y0': Y0})
# Create X update object
xstep = ConvBPDNMask(D0,
S,
lmbda,
W,
opt['CBPDN'],
method=xmethod,
dimK=dimK,
dimN=dimN)
# Create D update object
dstep = ConvCnstrMODMask(None,
S,
W,
dsz,
opt['CCMOD'],
method=dmethod,
dimK=dimK,
dimN=dimN)
# Configure iteration statistics reporting
isc = dictlrn.IterStatsConfig(isfld=dc.isfld(xmethod, dmethod, opt),
isxmap=dc.isxmap(xmethod, opt),
isdmap=dc.isdmap(dmethod),
evlmap=dc.evlmap(opt['AccurateDFid']),
hdrtxt=dc.hdrtxt(xmethod, dmethod, opt),
hdrmap=dc.hdrmap(xmethod, dmethod, opt),
fmtmap={
'It_X': '%4d',
'It_D': '%4d'
})
# Call parent constructor
super(ConvBPDNMaskDictLearn, self).__init__(xstep, dstep, opt, isc)
Normalise dictionary according to Y update options.
"""
D0n = cnvrep.Pcn(D0,
D0.shape,
cri.Nv,
dimN=2,
dimC=0,
crp=True,
zm=optd['ZeroMean'])
"""
Update D update options to include initial values for Y and U.
"""
optd.update({
'Y0': cnvrep.zpad(cnvrep.stdformD(D0n, cri.Cd, cri.M), cri.Nv),
'U0': np.zeros(cri.shpD)
})
"""
Create X update object.
"""
xstep = cbpdn.ConvBPDNJoint(D0n, sh, lmbda, mu, optx)
"""
Create D update object.
"""
dstep = ccmod.ConvCnstrMOD(None, sh, D0.shape, optd, method='ism')
"""
Create DictLearn object and solve.
"""
def __init__(self, D0, S, lmbda, W, opt=None, dimK=1, dimN=2):
"""
Initialise a MixConvBPDNMaskDcplDictLearn object with problem
size and options.
Parameters
----------
D0 : array_like
Initial dictionary array
S : array_like
Signal array
lmbda : float
Regularisation parameter
W : array_like
Mask array. The array shape must be such that the array is
compatible for multiplication with the *internal* shape of
input array S (see :class:`.cnvrep.CDU_ConvRepIndexing` for a
discussion of the distinction between *external* and *internal*
data layouts).
opt : :class:`MixConvBPDNMaskDcplDictLearn.Options` object
Algorithm options
dimK : int, optional (default 1)
Number of signal dimensions. If there is only a single input
signal (e.g. if `S` is a 2D array representing a single image)
`dimK` must be set to 0.
dimN : int, optional (default 2)
Number of spatial/temporal dimensions
"""
if opt is None:
opt = MixConvBPDNMaskDcplDictLearn.Options()
self.opt = opt
# Get dictionary size
if self.opt['DictSize'] is None:
dsz = D0.shape
else:
dsz = self.opt['DictSize']
# Construct object representing problem dimensions
cri = cr.CDU_ConvRepIndexing(dsz, S, dimK, dimN)
# Normalise dictionary
D0 = cr.Pcn(D0,
dsz,
cri.Nv,
dimN,
cri.dimCd,
crp=True,
zm=opt['CCMOD', 'ZeroMean'])
# Modify D update options to include initial values for X
X0 = cr.zpad(cr.stdformD(D0, cri.Cd, cri.M, dimN), cri.Nv)
opt['CCMOD'].update({'X0': X0})
# Create X update object
xstep = Acbpdn.ConvBPDNMaskDcpl(D0,
S,
lmbda,
W,
opt['CBPDN'],
dimK=dimK,
dimN=dimN)
# Create D update object
dstep = ccmod.ConvCnstrMODMask(None,
S,
W,
dsz,
opt['CCMOD'],
dimK=dimK,
dimN=dimN)
# Configure iteration statistics reporting
if self.opt['AccurateDFid']:
isxmap = {
'XPrRsdl': 'PrimalRsdl',
'XDlRsdl': 'DualRsdl',
'XRho': 'Rho'
}
evlmap = {'ObjFun': 'ObjFun', 'DFid': 'DFid', 'RegL1': 'RegL1'}
else:
isxmap = {
'ObjFun': 'ObjFun',
'DFid': 'DFid',
'RegL1': 'RegL1',
'XPrRsdl': 'PrimalRsdl',
'XDlRsdl': 'DualRsdl',
'XRho': 'Rho'
}
evlmap = {}
if dstep.opt['BackTrack', 'Enabled']:
isfld = [
'Iter', 'ObjFun', 'DFid', 'RegL1', 'Cnstr', 'XPrRsdl',
'XDlRsdl', 'XRho', 'D_F_Btrack', 'D_Q_Btrack', 'D_ItBt', 'D_L',
'Time'
]
isdmap = {
'Cnstr': 'Cnstr',
'D_F_Btrack': 'F_Btrack',
'D_Q_Btrack': 'Q_Btrack',
'D_ItBt': 'IterBTrack',
'D_L': 'L'
}
hdrtxt = [
'Itn', 'Fnc', 'DFid',
u('ℓ1'), 'Cnstr', 'r_X', 's_X',
u('ρ_X'), 'F_D', 'Q_D', 'It_D', 'L_D'
]
hdrmap = {
'Itn': 'Iter',
'Fnc': 'ObjFun',
'DFid': 'DFid',
u('ℓ1'): 'RegL1',
'Cnstr': 'Cnstr',
'r_X': 'XPrRsdl',
's_X': 'XDlRsdl',
u('ρ_X'): 'XRho',
'F_D': 'D_F_Btrack',
'Q_D': 'D_Q_Btrack',
'It_D': 'D_ItBt',
'L_D': 'D_L'
}
else:
isfld = [
'Iter', 'ObjFun', 'DFid', 'RegL1', 'Cnstr', 'XPrRsdl',
'XDlRsdl', 'XRho', 'D_L', 'Time'
]
isdmap = {'Cnstr': 'Cnstr', 'D_L': 'L'}
hdrtxt = [
'Itn', 'Fnc', 'DFid',
u('ℓ1'), 'Cnstr', 'r_X', 's_X',
u('ρ_X'), 'L_D'
]
hdrmap = {
'Itn': 'Iter',
'Fnc': 'ObjFun',
'DFid': 'DFid',
u('ℓ1'): 'RegL1',
'Cnstr': 'Cnstr',
'r_X': 'XPrRsdl',
's_X': 'XDlRsdl',
u('ρ_X'): 'XRho',
'L_D': 'D_L'
}
isc = dictlrn.IterStatsConfig(isfld=isfld,
isxmap=isxmap,
isdmap=isdmap,
evlmap=evlmap,
hdrtxt=hdrtxt,
hdrmap=hdrmap)
# Call parent constructor
super(MixConvBPDNMaskDcplDictLearn,
self).__init__(xstep, dstep, opt, isc)
def __init__(self,
D0,
S,
lmbda=None,
opt=None,
xmethod=None,
dmethod=None,
dimK=1,
dimN=2):
"""
|
**Call graph**
.. image:: ../_static/jonga/cbpdndl_init.svg
:width: 20%
:target: ../_static/jonga/cbpdndl_init.svg
|
Parameters
----------
D0 : array_like
Initial dictionary array
S : array_like
Signal array
lmbda : float
Regularisation parameter
opt : :class:`ConvBPDNDictLearn.Options` object
Algorithm options
xmethod : string, optional (default 'admm')
String selecting sparse coding solver. Valid values are
documented in function :func:`.ConvBPDN`.
dmethod : string, optional (default 'fista')
String selecting dictionary update solver. Valid values are
documented in function :func:`.ConvCnstrMOD`.
dimK : int, optional (default 1)
Number of signal dimensions. If there is only a single input
signal (e.g. if `S` is a 2D array representing a single image)
`dimK` must be set to 0.
dimN : int, optional (default 2)
Number of spatial/temporal dimensions
"""
if opt is None:
opt = ConvBPDNDictLearn.Options(xmethod=xmethod, dmethod=dmethod)
if xmethod is None:
xmethod = opt.xmethod
if dmethod is None:
dmethod = opt.dmethod
if opt.xmethod != xmethod or opt.dmethod != dmethod:
raise ValueError('Parameters xmethod and dmethod must have the '
'same values used to initialise the Options '
'object')
self.opt = opt
self.xmethod = xmethod
self.dmethod = dmethod
# Get dictionary size
if self.opt['DictSize'] is None:
dsz = D0.shape
else:
dsz = self.opt['DictSize']
# Construct object representing problem dimensions
cri = cr.CDU_ConvRepIndexing(dsz, S, dimK, dimN)
# Normalise dictionary
D0 = cr.Pcn(D0,
dsz,
cri.Nv,
dimN,
cri.dimCd,
crp=True,
zm=opt['CCMOD', 'ZeroMean'])
# Modify D update options to include initial value for Y
optname = 'X0' if dmethod == 'fista' else 'Y0'
opt['CCMOD'].update(
{optname: cr.zpad(cr.stdformD(D0, cri.Cd, cri.M, dimN), cri.Nv)})
# Create X update object
xstep = ConvBPDN(D0,
S,
lmbda,
opt['CBPDN'],
method=xmethod,
dimK=dimK,
dimN=dimN)
# Create D update object
dstep = ConvCnstrMOD(None,
S,
dsz,
opt['CCMOD'],
method=dmethod,
dimK=dimK,
dimN=dimN)
# Configure iteration statistics reporting
isc = dictlrn.IterStatsConfig(isfld=dc.isfld(xmethod, dmethod, opt),
isxmap=dc.isxmap(xmethod, opt),
isdmap=dc.isdmap(dmethod),
evlmap=dc.evlmap(opt['AccurateDFid']),
hdrtxt=dc.hdrtxt(xmethod, dmethod, opt),
hdrmap=dc.hdrmap(xmethod, dmethod, opt),
fmtmap={
'It_X': '%4d',
'It_D': '%4d'
})
# Call parent constructor
super(ConvBPDNDictLearn, self).__init__(xstep, dstep, opt, isc)
def __init__(self, D0, S, lmbda=None, opt=None, xmethod=None,
dmethod=None, dimK=1, dimN=2):
"""
|
**Call graph**
.. image:: ../_static/jonga/cbpdndl_init.svg
:width: 20%
:target: ../_static/jonga/cbpdndl_init.svg
|
Parameters
----------
D0 : array_like
Initial dictionary array
S : array_like
Signal array
lmbda : float
Regularisation parameter
opt : :class:`ConvBPDNDictLearn.Options` object
Algorithm options
xmethod : string, optional (default 'admm')
String selecting sparse coding solver. Valid values are
documented in function :func:`.ConvBPDN`.
dmethod : string, optional (default 'fista')
String selecting dictionary update solver. Valid values are
documented in function :func:`.ConvCnstrMOD`.
dimK : int, optional (default 1)
Number of signal dimensions. If there is only a single input
signal (e.g. if `S` is a 2D array representing a single image)
`dimK` must be set to 0.
dimN : int, optional (default 2)
Number of spatial/temporal dimensions
"""
if opt is None:
opt = ConvBPDNDictLearn.Options(xmethod=xmethod, dmethod=dmethod)
if xmethod is None:
xmethod = opt.xmethod
if dmethod is None:
dmethod = opt.dmethod
if opt.xmethod != xmethod or opt.dmethod != dmethod:
raise ValueError('Parameters xmethod and dmethod must have the '
'same values used to initialise the Options '
'object')
self.opt = opt
self.xmethod = xmethod
self.dmethod = dmethod
# Get dictionary size
if self.opt['DictSize'] is None:
dsz = D0.shape
else:
dsz = self.opt['DictSize']
# Construct object representing problem dimensions
cri = cr.CDU_ConvRepIndexing(dsz, S, dimK, dimN)
# Normalise dictionary
D0 = cr.Pcn(D0, dsz, cri.Nv, dimN, cri.dimCd, crp=True,
zm=opt['CCMOD', 'ZeroMean'])
# Modify D update options to include initial value for Y
optname = 'X0' if dmethod == 'fista' else 'Y0'
opt['CCMOD'].update({optname: cr.zpad(
cr.stdformD(D0, cri.Cd, cri.M, dimN), cri.Nv)})
# Create X update object
xstep = ConvBPDN(D0, S, lmbda, opt['CBPDN'], method=xmethod,
dimK=dimK, dimN=dimN)
# Create D update object
dstep = ConvCnstrMOD(None, S, dsz, opt['CCMOD'], method=dmethod,
dimK=dimK, dimN=dimN)
# Configure iteration statistics reporting
isc = dictlrn.IterStatsConfig(
isfld=dc.isfld(xmethod, dmethod, opt),
isxmap=dc.isxmap(xmethod, opt), isdmap=dc.isdmap(dmethod),
evlmap=dc.evlmap(opt['AccurateDFid']),
hdrtxt=dc.hdrtxt(xmethod, dmethod, opt),
hdrmap=dc.hdrmap(xmethod, dmethod, opt),
fmtmap={'It_X': '%4d', 'It_D': '%4d'})
# Call parent constructor
super(ConvBPDNDictLearn, self).__init__(xstep, dstep, opt, isc)
def __init__(self, D0, S, lmbda=None, opt=None, dimK=1, dimN=2):
"""
Initialise a ConvBPDNDictLearn object with problem size and options.
Parameters
----------
D0 : array_like
Initial dictionary array
S : array_like
Signal array
lmbda : float
Regularisation parameter
opt : :class:`ConvBPDNDictLearn.Options` object
Algorithm options
dimK : int, optional (default 1)
Number of signal dimensions. If there is only a single input
signal (e.g. if `S` is a 2D array representing a single image)
`dimK` must be set to 0.
dimN : int, optional (default 2)
Number of spatial/temporal dimensions
"""
if opt is None:
opt = ConvBPDNDictLearn.Options()
self.opt = opt
# Get dictionary size
if self.opt['DictSize'] is None:
dsz = D0.shape
else:
dsz = self.opt['DictSize']
# Construct object representing problem dimensions
cri = cr.CDU_ConvRepIndexing(dsz, S, dimK, dimN)
# Normalise dictionary
D0 = cr.Pcn(D0,
dsz,
cri.Nv,
dimN,
cri.dimCd,
crp=True,
zm=opt['CCMOD', 'ZeroMean'])
# Modify D update options to include initial values for X
opt['CCMOD'].update(
{'X0': cr.zpad(cr.stdformD(D0, cri.C, cri.M, dimN), cri.Nv)})
# Create X update object
xstep = Fcbpdn.ConvBPDN(D0,
S,
lmbda,
opt['CBPDN'],
dimK=dimK,
dimN=dimN)
# Create D update object
dstep = ccmod.ConvCnstrMOD(None,
S,
dsz,
opt['CCMOD'],
dimK=dimK,
dimN=dimN)
print("L xstep in cbpdndl: ", xstep.L)
print("L dstep in cbpdndl: ", dstep.L)
# Configure iteration statistics reporting
isfld = ['Iter', 'ObjFun', 'DFid', 'RegL1', 'Cnstr']
hdrtxt = ['Itn', 'Fnc', 'DFid', u('ℓ1'), 'Cnstr']
hdrmap = {
'Itn': 'Iter',
'Fnc': 'ObjFun',
'DFid': 'DFid',
u('ℓ1'): 'RegL1',
'Cnstr': 'Cnstr'
}
if self.opt['AccurateDFid']:
isxmap = {
'X_F_Btrack': 'F_Btrack',
'X_Q_Btrack': 'Q_Btrack',
'X_ItBt': 'IterBTrack',
'X_L': 'L',
'X_Rsdl': 'Rsdl'
}
evlmap = {'ObjFun': 'ObjFun', 'DFid': 'DFid', 'RegL1': 'RegL1'}
else:
isxmap = {
'ObjFun': 'ObjFun',
'DFid': 'DFid',
'RegL1': 'RegL1',
'X_F_Btrack': 'F_Btrack',
'X_Q_Btrack': 'Q_Btrack',
'X_ItBt': 'IterBTrack',
'X_L': 'L',
'X_Rsdl': 'Rsdl'
}
evlmap = {}
# If Backtracking enabled in xstep display the BT variables also
if xstep.opt['BackTrack', 'Enabled']:
isfld.extend(
['X_F_Btrack', 'X_Q_Btrack', 'X_ItBt', 'X_L', 'X_Rsdl'])
hdrtxt.extend(['F_X', 'Q_X', 'It_X', 'L_X'])
hdrmap.update({
'F_X': 'X_F_Btrack',
'Q_X': 'X_Q_Btrack',
'It_X': 'X_ItBt',
'L_X': 'X_L'
})
else: # Add just L value to xstep display
isfld.extend(['X_L', 'X_Rsdl'])
hdrtxt.append('L_X')
hdrmap.update({'L_X': 'X_L'})
isdmap = {
'Cnstr': 'Cnstr',
'D_F_Btrack': 'F_Btrack',
'D_Q_Btrack': 'Q_Btrack',
'D_ItBt': 'IterBTrack',
'D_L': 'L',
'D_Rsdl': 'Rsdl'
}
# If Backtracking enabled in dstep display the BT variables also
if dstep.opt['BackTrack', 'Enabled']:
isfld.extend([
'D_F_Btrack', 'D_Q_Btrack', 'D_ItBt', 'D_L', 'D_Rsdl', 'Time'
])
hdrtxt.extend(['F_D', 'Q_D', 'It_D', 'L_D'])
hdrmap.update({
'F_D': 'D_F_Btrack',
'Q_D': 'D_Q_Btrack',
'It_D': 'D_ItBt',
'L_D': 'D_L'
})
else: # Add just L value to dstep display
isfld.extend(['D_L', 'D_Rsdl', 'Time'])
hdrtxt.append('L_D')
hdrmap.update({'L_D': 'D_L'})
isc = dictlrn.IterStatsConfig(isfld=isfld,
isxmap=isxmap,
isdmap=isdmap,
evlmap=evlmap,
hdrtxt=hdrtxt,
hdrmap=hdrmap)
# Call parent constructor
super(ConvBPDNDictLearn, self).__init__(xstep, dstep, opt, isc)
def __init__(self,
D0,
S,
lmbda,
W,
opt=None,
method='cns',
dimK=1,
dimN=2):
"""
Initialise a ConvBPDNMaskDcplDictLearn object with problem size and
options.
|
**Call graph**
.. image:: _static/jonga/cbpdnmddl_init.svg
:width: 20%
:target: _static/jonga/cbpdnmddl_init.svg
|
Parameters
----------
D0 : array_like
Initial dictionary array
S : array_like
Signal array
lmbda : float
Regularisation parameter
W : array_like
Mask array. The array shape must be such that the array is
compatible for multiplication with the *internal* shape of
input array S (see :class:`.cnvrep.CDU_ConvRepIndexing` for a
discussion of the distinction between *external* and *internal*
data layouts).
opt : :class:`ConvBPDNMaskDcplDictLearn.Options` object
Algorithm options
method : string, optional (default 'cns')
String selecting dictionary update solver. Valid values are
documented in function :func:`.ConvCnstrMODMaskDcpl`.
dimK : int, optional (default 1)
Number of signal dimensions. If there is only a single input
signal (e.g. if `S` is a 2D array representing a single image)
`dimK` must be set to 0.
dimN : int, optional (default 2)
Number of spatial/temporal dimensions
"""
if opt is None:
opt = ConvBPDNMaskDcplDictLearn.Options(method=method)
self.opt = opt
# Get dictionary size
if self.opt['DictSize'] is None:
dsz = D0.shape
else:
dsz = self.opt['DictSize']
# Construct object representing problem dimensions
cri = cr.CDU_ConvRepIndexing(dsz, S, dimK, dimN)
# Normalise dictionary
D0 = cr.Pcn(D0,
dsz,
cri.Nv,
dimN,
cri.dimCd,
crp=True,
zm=opt['CCMOD', 'ZeroMean'])
# Modify D update options to include initial values for Y and U
if cri.C == cri.Cd:
Y0b0 = np.zeros(cri.Nv + (cri.C, 1, cri.K))
else:
Y0b0 = np.zeros(cri.Nv + (1, 1, cri.C * cri.K))
Y0b1 = cr.zpad(cr.stdformD(D0, cri.Cd, cri.M, dimN), cri.Nv)
if method == 'cns':
Y0 = Y0b1
else:
Y0 = np.concatenate((Y0b0, Y0b1), axis=cri.axisM)
opt['CCMOD'].update({'Y0': Y0})
# Create X update object
xstep = cbpdn.ConvBPDNMaskDcpl(D0,
S,
lmbda,
W,
opt['CBPDN'],
dimK=dimK,
dimN=dimN)
# Create D update object
dstep = ccmodmd.ConvCnstrMODMaskDcpl(None,
S,
W,
dsz,
opt['CCMOD'],
method=method,
dimK=dimK,
dimN=dimN)
# Configure iteration statistics reporting
if self.opt['AccurateDFid']:
isxmap = {
'XPrRsdl': 'PrimalRsdl',
'XDlRsdl': 'DualRsdl',
'XRho': 'Rho'
}
evlmap = {'ObjFun': 'ObjFun', 'DFid': 'DFid', 'RegL1': 'RegL1'}
else:
isxmap = {
'ObjFun': 'ObjFun',
'DFid': 'DFid',
'RegL1': 'RegL1',
'XPrRsdl': 'PrimalRsdl',
'XDlRsdl': 'DualRsdl',
'XRho': 'Rho'
}
evlmap = {}
isc = dictlrn.IterStatsConfig(isfld=[
'Iter', 'ObjFun', 'DFid', 'RegL1', 'Cnstr', 'XPrRsdl', 'XDlRsdl',
'XRho', 'DPrRsdl', 'DDlRsdl', 'DRho', 'Time'
],
isxmap=isxmap,
isdmap={
'Cnstr': 'Cnstr',
'DPrRsdl': 'PrimalRsdl',
'DDlRsdl': 'DualRsdl',
'DRho': 'Rho'
},
evlmap=evlmap,
hdrtxt=[
'Itn', 'Fnc', 'DFid',
u('ℓ1'), 'Cnstr', 'r_X', 's_X',
u('ρ_X'), 'r_D', 's_D',
u('ρ_D')
],
hdrmap={
'Itn': 'Iter',
'Fnc': 'ObjFun',
'DFid': 'DFid',
u('ℓ1'): 'RegL1',
'Cnstr': 'Cnstr',
'r_X': 'XPrRsdl',
's_X': 'XDlRsdl',
u('ρ_X'): 'XRho',
'r_D': 'DPrRsdl',
's_D': 'DDlRsdl',
u('ρ_D'): 'DRho'
})
# Call parent constructor
super(ConvBPDNMaskDcplDictLearn, self).__init__(xstep, dstep, opt, isc)
def __init__(self,
D0,
S,
lmbda=None,
opt=None,
method='cns',
dimK=1,
dimN=2,
stopping_pobj=None):
"""
Initialise a ConvBPDNDictLearn object with problem size and options.
|
**Call graph**
.. image:: _static/jonga/cbpdndl_init.svg
:width: 20%
:target: _static/jonga/cbpdndl_init.svg
|
Parameters
----------
D0 : array_like
Initial dictionary array
S : array_like
Signal array
lmbda : float
Regularisation parameter
opt : :class:`ConvBPDNDictLearn.Options` object
Algorithm options
method : string, optional (default 'cns')
String selecting dictionary update solver. Valid values are
documented in function :func:`.ConvCnstrMOD`.
dimK : int, optional (default 1)
Number of signal dimensions. If there is only a single input
signal (e.g. if `S` is a 2D array representing a single image)
`dimK` must be set to 0.
dimN : int, optional (default 2)
Number of spatial/temporal dimensions
"""
if opt is None:
opt = ConvBPDNDictLearn.Options(method=method)
self.opt = opt
self.stopping_pobj = stopping_pobj
# Get dictionary size
if self.opt['DictSize'] is None:
dsz = D0.shape
else:
dsz = self.opt['DictSize']
# Construct object representing problem dimensions
cri = cr.CDU_ConvRepIndexing(dsz, S, dimK, dimN)
# Normalise dictionary
D0 = cr.Pcn(D0,
dsz,
cri.Nv,
dimN,
cri.dimCd,
crp=True,
zm=opt['CCMOD', 'ZeroMean'])
# Modify D update options to include initial values for Y and U
opt['CCMOD'].update(
{'Y0': cr.zpad(cr.stdformD(D0, cri.C, cri.M, dimN), cri.Nv)})
# Create X update object
xstep = cbpdn.ConvBPDN(D0,
S,
lmbda,
opt['CBPDN'],
dimK=dimK,
dimN=dimN)
# Create D update object
dstep = ccmod.ConvCnstrMOD(None,
S,
dsz,
opt['CCMOD'],
method=method,
dimK=dimK,
dimN=dimN)
# Configure iteration statistics reporting
if self.opt['AccurateDFid']:
isxmap = {
'XPrRsdl': 'PrimalRsdl',
'XDlRsdl': 'DualRsdl',
'XRho': 'Rho'
}
evlmap = {'ObjFun': 'ObjFun', 'DFid': 'DFid', 'RegL1': 'RegL1'}
else:
isxmap = {
'ObjFun': 'ObjFun',
'DFid': 'DFid',
'RegL1': 'RegL1',
'XPrRsdl': 'PrimalRsdl',
'XDlRsdl': 'DualRsdl',
'XRho': 'Rho'
}
evlmap = {}
isc = dictlrn.IterStatsConfig(isfld=[
'Iter', 'ObjFun', 'DFid', 'RegL1', 'Cnstr', 'XPrRsdl', 'XDlRsdl',
'XRho', 'DPrRsdl', 'DDlRsdl', 'DRho', 'Time'
],
isxmap=isxmap,
isdmap={
'Cnstr': 'Cnstr',
'DPrRsdl': 'PrimalRsdl',
'DDlRsdl': 'DualRsdl',
'DRho': 'Rho'
},
evlmap=evlmap,
hdrtxt=[
'Itn', 'Fnc', 'DFid',
u('ℓ1'), 'Cnstr', 'r_X', 's_X',
u('ρ_X'), 'r_D', 's_D',
u('ρ_D')
],
hdrmap={
'Itn': 'Iter',
'Fnc': 'ObjFun',
'DFid': 'DFid',
u('ℓ1'): 'RegL1',
'Cnstr': 'Cnstr',
'r_X': 'XPrRsdl',
's_X': 'XDlRsdl',
u('ρ_X'): 'XRho',
'r_D': 'DPrRsdl',
's_D': 'DDlRsdl',
u('ρ_D'): 'DRho'
})
# Call parent constructor
super(ConvBPDNDictLearn, self).__init__(xstep, dstep, opt, isc)
method='ism')
"""
Normalise dictionary according to dictionary Y update options.
"""
D0n = cnvrep.Pcn(D0, D0.shape, cri.Nv, dimN=2, dimC=0, crp=True,
zm=optd['ZeroMean'])
"""
Update D update options to include initial values for Y and U.
"""
optd.update({'Y0': cnvrep.zpad(cnvrep.stdformD(D0n, cri.Cd, cri.M), cri.Nv),
'U0': np.zeros(cri.shpD)})
"""
Create X update object.
"""
xstep = cbpdn.ConvBPDNJoint(D0n, sh, lmbda, mu, optx)
"""
Create D update object.
"""
dstep = ccmod.ConvCnstrMOD(None, sh, D0.shape, optd, method='ism')
def nakashizuka_solve(
cri, Dr0, Xr, Sr,
final_sigma,
maxitr = 40,
param_mu = 1,
param_lambda = 1e-2,
debug_dir = None
):
param_rho = 0.5
Xr = Xr.copy()
Sr = Sr.copy()
Dr = Dr0.copy()
Hr = np.zeros_like(cnvrep.zpad(Dr, cri.Nv))
Sf = to_frequency(cri, Sr)
# sigma set
# sigma_list = []
# sigma_list.append(Xr.max()*4)
# for i in range(7):
# sigma_list.append(sigma_list[i]*0.5)
first_sigma = Xr.max()*4
c = (final_sigma / first_sigma) ** (1/(maxitr - 1))
print("c = %.8f" % c)
sigma_list = []
sigma_list.append(first_sigma)
for i in range(maxitr - 1):
sigma_list.append(sigma_list[i]*c)
crop_op = []
for l in Dr.shape:
crop_op.append(slice(0, l))
crop_op = tuple(crop_op)
Pcn = cnvrep.getPcn(Dr.shape, cri.Nv, cri.dimN, cri.dimCd, zm=False)
updcnt = 0
dictcnt = 0
for sigma in sigma_list:
print("sigma = %.8f" % sigma)
# Xf_old = sl.rfftn(Xr, cri.Nv, cri.axisN)
for l in range(1):
# print("l0norm: %f" % l0norm(Xr, sigma_list[-1]))
# print('error1: ', l2norm(Sr - reconstruct(cri, Dr, Xr)))
# print("l2(Xr): %.6f, l2(delta): %.6f" % (l2norm(Xr), l2norm(delta)))
delta = Xr * np.exp(-(Xr*Xr) / (2*sigma*sigma))
Xr = Xr - param_mu*delta# + np.random.randn(*Xr.shape)*sigma*1e-1
Xf = to_frequency(cri, Xr)
# print('error2: ', l2norm(Sr - reconstruct(cri, Dr, Xr)))
Df = to_frequency(cri, Dr)
b = Xf / param_lambda + np.conj(Df) * Sf
Xf = sl.solvedbi_sm(Df, 1/param_lambda, b, axis=cri.axisM)
Xr = to_spatial(cri, Xf).astype(np.float32)
# print('error3: ', l2norm(Sr - reconstruct(cri, Dr, Xr)))
# save_reconstructed(cri, Dr, Xr, Sr, "./rec/%da.png" % reccnt)
# saveXhist(Xr, "./hist/%da.png" % reccnt)
Dr, Hr = update_dict(cri, Pcn, crop_op, Xr, Dr, Hr, Sf, param_rho)
Df = to_frequency(cri, Dr)
# print('error4: ', l2norm(Sr - reconstruct(cri, Dr, Xr)))
# # project X to solution space
# b = sl.inner(Df, Xf, axis=cri.axisM) - Sf
# c = sl.inner(Df, np.conj(Df), axis=cri.axisM)
# Xf = Xf - np.conj(Df) / c * b
# Xr = sl.irfftn(Xf, s=cri.Nv, axes=cri.axisN)
# print('error5: ', l2norm(Sr - reconstruct(cri, Dr, Xr)))
if debug_dir is not None:
saveimg(util.tiledict(Dr.squeeze()), debug_dir + "/dict/%d.png" % updcnt)
updcnt += 1
# saveXhist(Xr, "Xhist_sigma=" + str(sigma) + ".png")
# print("l0 norm of final X: %d" % smoothedl0norm(Xr, 0.00001))
plot.close()
mplot.close()
return Dr
Sh = S*2 - Smean
# TODO: explicitly zero-padding (for me, foolish)
D = np.random.randn(12, 12, 256)
# D = np.random.rand(12, 12, 64)*2 - 1
cri = cnvrep.CSC_ConvRepIndexing(D, S)
Dr0 = np.asarray(D.reshape(cri.shpD), dtype=S.dtype)
Slr = np.asarray(Sl.reshape(cri.shpS), dtype=S.dtype)
Shr = np.asarray(Sh.reshape(cri.shpS), dtype=S.dtype)
Shf = sl.rfftn(Shr, s=cri.Nv, axes=cri.axisN) # implicitly zero-padding
crop_op = []
for l in Dr0.shape:
crop_op.append(slice(0, l))
crop_op = tuple(crop_op)
Dr0 = cnvrep.getPcn(Dr0.shape, cri.Nv, cri.dimN, cri.dimCd, zm=False)(cnvrep.zpad(Dr0, cri.Nv))[crop_op]
# Dr = normalize(Dr, axis=cri.axisM)
# Xr = l2norm_minimize(cri, Dr0, Shr)
# Dr = mysolve(cri, Dr0, Xr, Shr, 1e-4, maxitr=50, debug_dir='./debug')
# # Dr = nakashizuka_solve(cri, Dr0, Xr, Shr, debug_dir='./debug')
# # Dr = sporcosolve(cri, Dr, Shr)
# # fig = plot.figure(figsize=(7, 7))
# # plot.imview(util.tiledict(Dr.squeeze()), fig=fig)
# # fig.savefig('dict.png')
# # # evaluate_result(cri, Dr0, Dr, Shr, Sr_add=Slr)
exim1 = util.ExampleImages(scaled=True, zoom=0.5, pth='./')
S1_test = exim1.image('couple.tiff')
exim2 = util.ExampleImages(scaled=True, zoom=1, pth='./')
