def config_itstats(self):
"""Setup config fields."""
# NOTE: BackTrack is not implemented so always False.
isfld = ['Iter', 'ObjFun', 'DFid', 'RegL1',
'XPrRsdl', 'XDlRsdl', 'XRho', 'X_It',
'D_L', 'D_Rsdl', 'D_It', 'Time']
isxmap = {'XPrRsdl': 'PrimalRsdl', 'XDlRsdl': 'DualRsdl',
'XRho': 'Rho', 'X_It': 'Iter'}
isdmap = {'D_L': 'L', 'D_Rsdl': 'Rsdl', 'D_It': 'Iter'}
hdrtxt = ['Itn', 'Fnc', 'DFid', u('ℓ1'),
'Itn_X', 'r_X', 's_X', u('ρ_X'),
'Itn_D', 'r_D', 'L_D', 'Time']
hdrmap = {'Itn': 'Iter', 'Fnc': 'ObjFun', 'DFid': 'DFid',
u('ℓ1'): 'RegL1', 'r_X': 'XPrRsdl', 's_X': 'XDlRsdl',
u('ρ_X'): 'XRho', 'Itn_X': 'X_It',
'r_D': 'D_Rsdl', 'L_D': 'D_L', 'Itn_D': 'D_It', 'Time': 'Time'}
_evlmap = {'ObjFun': 'ObjFun', 'DFid': 'DFid', 'RegL1': 'RegL1'}
if self.opt['AccurateDFid']:
evlmap = _evlmap
else:
evlmap = {}
isxmap.update(_evlmap)
return dictlrn.IterStatsConfig(
isfld=isfld, isxmap=isxmap, isdmap=isdmap, evlmap=evlmap,
hdrtxt=hdrtxt, hdrmap=hdrmap,
fmtmap={'Itn_X': '%4d', 'Itn_D': '%4d'}
)
def config_itstats(self):
"""Config itstats output."""
isfld = [
'Iter', 'ObjFun', 'DFid', 'RegL1', 'Cnstr', 'XPrRsdl', 'XDlRsdl',
'XRho', 'DPrRsdl', 'DDlRsdl', 'DRho', 'Time'
]
isxmap = {
'XPrRsdl': 'PrimalRsdl',
'XDlRsdl': 'DualRsdl',
'XRho': 'Rho'
}
isdmap = {
'DPrRsdl': 'PrimalRsdl',
'DDlRsdl': 'DualRsdl',
'DRho': 'Rho',
'Cnstr': 'Cnstr'
}
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'
}
_evlmap = {'ObjFun': 'ObjFun', 'DFid': 'DFid', 'RegL1': 'RegL1'}
if self.opt['AccurateDFid']:
evlmap = _evlmap
else:
evlmap = {}
isxmap.update(_evlmap)
return dictlrn.IterStatsConfig(isfld=isfld,
isxmap=isxmap,
isdmap=isdmap,
evlmap=evlmap,
hdrtxt=hdrtxt,
hdrmap=hdrmap)
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)
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):
"""
|
**Call graph**
.. image:: ../_static/jonga/bpdndl_init.svg
:width: 20%
:target: ../_static/jonga/bpdndl_init.svg
|
Parameters
----------
D0 : array_like, shape (N, M)
Initial dictionary matrix
S : array_like, shape (N, K)
Signal vector or matrix
lmbda : float
Regularisation parameter
opt : :class:`BPDNDictLearn.Options` object
Algorithm options
"""
if opt is None:
opt = BPDNDictLearn.Options()
self.opt = opt
# Normalise dictionary according to D update options
D0 = cmod.getPcn(opt['CMOD', 'ZeroMean'])(D0)
# Modify D update options to include initial values for Y and U
Nc = D0.shape[1]
opt['CMOD'].update({'Y0': D0, 'U0': np.zeros((S.shape[0], Nc))})
# Create X update object
xstep = bpdn.BPDN(D0, S, lmbda, opt['BPDN'])
# Create D update object
Nm = S.shape[1]
dstep = cmod.CnstrMOD(xstep.Y, S, (Nc, Nm), opt['CMOD'])
# 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(BPDNDictLearn, self).__init__(xstep, dstep, opt, isc)
def config_itstats(self):
"""Config itstats output for fista."""
# isfld
isfld = ['Iter', 'ObjFun', 'DFid', 'RegL1', 'Cnstr']
if self.opt['CBPDN', 'BackTrack', 'Enabled']:
isfld.extend(
['X_F_Btrack', 'X_Q_Btrack', 'X_ItBt', 'X_L', 'X_Rsdl'])
else:
isfld.extend(['X_L', 'X_Rsdl'])
if self.opt['CCMOD', 'BackTrack', 'Enabled']:
isfld.extend(
['D_F_Btrack', 'D_Q_Btrack', 'D_ItBt', 'D_L', 'D_Rsdl'])
else:
isfld.extend(['D_L', 'D_Rsdl'])
isfld.extend(['Time'])
# isxmap/isdmap
isxmap = {
'X_F_Btrack': 'F_Btrack',
'X_Q_Btrack': 'Q_Btrack',
'X_ItBt': 'IterBTrack',
'X_L': 'L',
'X_Rsdl': 'Rsdl'
}
isdmap = {
'Cnstr': 'Cnstr',
'D_F_Btrack': 'F_Btrack',
'D_Q_Btrack': 'Q_Btrack',
'D_ItBt': 'IterBTrack',
'D_L': 'L',
'D_Rsdl': 'Rsdl'
}
# hdrtxt
hdrtxt = ['Itn', 'Fnc', 'DFid', u('ℓ1'), 'Cnstr']
if self.opt['CBPDN', 'BackTrack', 'Enabled']:
hdrtxt.extend(['F_X', 'Q_X', 'It_X', 'L_X'])
else:
hdrtxt.append('L_X')
if self.opt['CCMOD', 'BackTrack', 'Enabled']:
hdrtxt.extend(['F_D', 'Q_D', 'It_D', 'L_D'])
else:
hdrtxt.append('L_D')
# hdrmap
hdrmap = {
'Itn': 'Iter',
'Fnc': 'ObjFun',
'DFid': 'DFid',
u('ℓ1'): 'RegL1',
'Cnstr': 'Cnstr'
}
if self.opt['CBPDN', 'BackTrack', 'Enabled']:
hdrmap.update({
'F_X': 'X_F_Btrack',
'Q_X': 'X_Q_Btrack',
'It_X': 'X_ItBt',
'L_X': 'X_L'
})
else:
hdrmap.update({'L_X': 'X_L'})
if self.opt['CCMOD', 'BackTrack', 'Enabled']:
hdrmap.update({
'F_D': 'D_F_Btrack',
'Q_D': 'D_Q_Btrack',
'It_D': 'D_ItBt',
'L_D': 'D_L'
})
else:
hdrmap.update({'L_D': 'D_L'})
# evlmap
_evlmap = {'ObjFun': 'ObjFun', 'DFid': 'DFid', 'RegL1': 'RegL1'}
if self.opt['AccurateDFid']:
evlmap = _evlmap
else:
evlmap = {}
isxmap.update(_evlmap)
# fmtmap
fmtmap = {'It_X': '%4d', 'It_D': '%4d'}
return dictlrn.IterStatsConfig(isfld=isfld,
isxmap=isxmap,
isdmap=isdmap,
evlmap=evlmap,
hdrtxt=hdrtxt,
hdrmap=hdrmap,
fmtmap=fmtmap)
def __init__(self, D0, S, lmbda=None, W=None, opt=None):
"""
Parameters
----------
D0 : array_like, shape (N, M)
Initial dictionary matrix
S : array_like, shape (N, K)
Signal vector or matrix
lmbda : float
Regularisation parameter
W : array_like, shape (N, K)
Weight matrix
opt : :class:`WeightedBPDNDictLearn.Options` object
Algorithm options
"""
if opt is None:
opt = WeightedBPDNDictLearn.Options()
self.opt = opt
# Normalise dictionary according to D update options
D0 = cmod.getPcn(opt['CMOD', 'ZeroMean'],
opt['CMOD', 'NonNegCoef'])(D0)
# Modify D update options to include initial values for Y and U
Nc = D0.shape[1]
opt['CMOD'].update({'X0': D0})
# Create X update object
xstep = bpdn.WeightedBPDN(D0, S, lmbda, W=W, opt=opt['BPDN'])
# Create D update object
Nm = S.shape[1]
dstep = cmod.WeightedCnstrMOD(xstep.Y, S, W=W, dsz=(Nc, Nm),
opt=opt['CMOD'])
if W is None:
W = np.array([1.0], dtype=xstep.dtype)
if W.ndim > 0:
W = atleast_nd(2, W)
self.W = np.asarray(W, dtype=xstep.dtype)
# Configure iteration statistics reporting
if self.opt['AccurateDFid']:
isxmap = {'XRsdl': 'Rsdl', 'XL': 'L'}
evlmap = {'ObjFun': 'ObjFun', 'DFid': 'DFid', 'RegL1': 'RegL1'}
else:
isxmap = {'ObjFun': 'ObjFun', 'DFid': 'DFid', 'RegL1': 'RegL1',
'XRsdl': 'Rsdl', 'XL': 'L'}
evlmap = {}
isc = dictlrn.IterStatsConfig(
isfld=['Iter', 'ObjFun', 'DFid', 'RegL1', 'Cnstr', 'XRsdl',
'XL', 'DRsdl', 'DL', 'Time'],
isxmap=isxmap,
isdmap={'Cnstr': 'Cnstr', 'DRsdl': 'Rsdl', 'DL': 'L'},
evlmap=evlmap,
hdrtxt=['Itn', 'Fnc', 'DFid', u('ℓ1'), 'Cnstr', 'X_Rsdl',
'X_L', 'D_Rsdl', 'D_L'],
hdrmap={'Itn': 'Iter', 'Fnc': 'ObjFun', 'DFid': 'DFid',
u('ℓ1'): 'RegL1', 'Cnstr': 'Cnstr', 'X_Rsdl': 'XRsdl',
'X_L': 'XL', 'D_Rsdl': 'DRsdl', 'D_L': 'DL'}
)
# Call parent constructor
super(WeightedBPDNDictLearn, self).__init__(xstep, dstep, opt, isc)
