def obfn_dfd(self):
r"""Compute data fidelity term :math:`(1/2) \| \sum_m
\mathbf{d}_m * \mathbf{x}_m - \mathbf{s} \|_2^2`.
"""
Ef = self.eval_Rf(self.Xf)
return sl.rfl2norm2(Ef, self.S.shape, axis=self.cri.axisN) / 2.0
def obfn_dfd(self):
r"""Compute data fidelity term :math:`(1/2) \| \sum_m
\mathbf{d}_m * \mathbf{x}_m - \mathbf{s} \|_2^2`.
"""
Ef = self.eval_Rf(self.Xf)
return sl.rfl2norm2(Ef, self.S.shape, axis=self.cri.axisN) / 2.0
def obfn_dfd(self):
r"""Compute data fidelity term :math:`(1/2) \| \sum_m
\mathbf{d}_m * \mathbf{x}_m - \mathbf{s} \|_2^2`.
"""
Ef = sl.inner(self.Zf, self.obfn_fvarf(), axis=self.cri.axisM) \
- self.Sf
return sl.rfl2norm2(Ef, self.S.shape, axis=self.cri.axisN) / 2.0
def obfn_dfd(self):
r"""Compute data fidelity term :math:`(1/2) \| \sum_m
\mathbf{d}_m * \mathbf{x}_m - \mathbf{s} \|_2^2`.
"""
Ef = sl.inner(self.Zf, self.obfn_fvarf(), axis=self.cri.axisM) \
- self.Sf
return sl.rfl2norm2(Ef, self.S.shape, axis=self.cri.axisN) / 2.0
def obfn_dfd(self):
r"""Compute data fidelity term :math:`(1/2) \| \sum_m \mathbf{d}_m *
\mathbf{x}_m - \mathbf{s} \|_2^2`.
"""
Ef = np.sum(self.Df * self.obfn_fvarf(), axis=self.cri.axisM,
keepdims=True) - self.Sf
return sl.rfl2norm2(Ef, self.S.shape, axis=self.cri.axisN)/2.0
def obfn_dfd(self):
r"""Compute data fidelity term :math:`(1/2) \| D X B - S \|_2^2`.
"""
DXBf = sl.dot(self.B, sl.inner(self.Df, self.obfn_fvarf(),
axis=self.cri.axisM),
axis=self.cri.axisC)
Ef = DXBf - self.Sf
return sl.rfl2norm2(Ef, self.S.shape, axis=self.cri.axisN) / 2.0
def obfn_dfd(self):
r"""Compute data fidelity term :math:`(1/2) \| D X B - S \|_2^2`.
"""
DXBf = sl.dot(self.B, sl.inner(self.Df, self.obfn_fvarf(),
axis=self.cri.axisM),
axis=self.cri.axisC)
Ef = DXBf - self.Sf
return sl.rfl2norm2(Ef, self.S.shape, axis=self.cri.axisN) / 2.0
def obfn_reg(self):
r"""Compute regularisation terms and contribution to objective
function. Regularisation terms are :math:`\| Y \|_1` and
:math:`\| Y \|_{2,1}`.
"""
rl21 = np.sum(self.wl21 * np.sqrt(np.sum(self.obfn_gvar()**2,
axis=self.cri.axisC)))
rgr = sl.rfl2norm2(np.sqrt(self.GHGf*np.conj(fvf)*fvf), self.cri.Nv,
self.cri.axisN)/2.0
return (self.lmbda*rl21 + self.mu*rgr, rl21, rgr)
def obfn_reg(self):
r"""Compute regularisation terms and contribution to objective
function. Regularisation terms are :math:`\| Y \|_1` and
:math:`\| Y \|_{2,1}`.
"""
rl21 = np.sum(self.wl21 * np.sqrt(np.sum(self.obfn_gvar()**2,
axis=self.cri.axisC)))
rgr = sl.rfl2norm2(np.sqrt(self.GHGf*np.conj(fvf)*fvf), self.cri.Nv,
self.cri.axisN)/2.0
return (self.lmbda*rl21 + self.mu*rgr, rl21, rgr)
def obfn_dfd(self):
r"""Compute data fidelity term :math:`(1/2) \| \sum_m
\mathbf{d}_m * \mathbf{x}_m - \mathbf{s} \|_2^2`.
This function takes into account the unnormalised DFT scaling,
i.e. given that the variables are the DFT of multi-dimensional
arrays computed via :func:`rfftn`, this returns the data fidelity
term in the original (spatial) domain.
"""
Ef = self.eval_Rf(self.Xf)
return sl.rfl2norm2(Ef, self.S.shape, axis=self.cri.axisN) / 2.0
def obfn_dfd(self):
r"""Compute data fidelity term :math:`(1/2) \| \sum_m
\mathbf{d}_m * \mathbf{x}_m - \mathbf{s} \|_2^2`.
This function takes into account the unnormalised DFT scaling,
i.e. given that the variables are the DFT of multi-dimensional
arrays computed via :func:`rfftn`, this returns the data fidelity
term in the original (spatial) domain.
"""
Ef = self.eval_Rf(self.Xf)
return sl.rfl2norm2(Ef, self.S.shape, axis=self.cri.axisN) / 2.0
def evaluate(self, S, X):
"""Optionally evaluate functional values."""
if self.opt['AccurateDFid']:
Df = sl.rfftn(self.D, self.cri.Nv, self.cri.axisN)
Xf = sl.rfftn(X, self.cri.Nv, self.cri.axisN)
Sf = sl.rfftn(S, self.cri.Nv, self.cri.axisN)
Ef = sl.inner(Df, Xf, axis=self.cri.axisM) - Sf
dfd = sl.rfl2norm2(Ef, S.shape, axis=self.cri.axisN) / 2.
rl1 = np.sum(np.abs(X))
evl = dict(DFid=dfd, RegL1=rl1, ObjFun=dfd+self.lmbda*rl1)
else:
evl = None
return evl
def eval_objfn(self):
r"""Compute components of objective function as well as total
contribution to objective function. Data fidelity term is
:math:`(1/2) \| H \mathbf{x} - \mathbf{s} \|_2^2` and
regularisation term is :math:`\| W_{\mathrm{tv}}
\sqrt{(G_r \mathbf{x})^2 + (G_c \mathbf{x})^2}\|_1`.
"""
Ef = self.Af * self.Xf - self.Sf
dfd = sl.rfl2norm2(Ef, self.S.shape, axis=self.axes) / 2.0
reg = np.sum(self.Wtv * np.sqrt(np.sum(self.obfn_gvar()**2,
axis=self.saxes)))
obj = dfd + self.lmbda*reg
return (obj, dfd, reg)
def eval_objfn(self):
r"""Compute components of objective function as well as total
contribution to objective function. Data fidelity term is
:math:`(1/2) \| H \mathbf{x} - \mathbf{s} \|_2^2` and
regularisation term is :math:`\| W_{\mathrm{tv}}
\sqrt{(G_r \mathbf{x})^2 + (G_c \mathbf{x})^2}\|_1`.
"""
Ef = self.Af * self.Xf - self.Sf
dfd = sl.rfl2norm2(Ef, self.S.shape, axis=self.axes) / 2.0
reg = np.sum(self.Wtv * np.sqrt(np.sum(self.obfn_gvar()**2,
axis=self.saxes)))
obj = dfd + self.lmbda*reg
return (obj, dfd, reg)
def evaluate(self):
"""Evaluate functional value of previous iteration."""
X = mp_Z_Y
Xf = mp_Zf
Df = mp_Df
Sf = mp_Sf
Ef = sl.inner(Df[np.newaxis, ...], Xf,
axis=self.xstep.cri.axisM + 1) - Sf
Ef = np.swapaxes(Ef, 0, self.xstep.cri.axisK + 1)[0]
dfd = sl.rfl2norm2(Ef, self.xstep.S.shape,
axis=self.xstep.cri.axisN) / 2.0
rl1 = np.sum(np.abs(X))
obj = dfd + self.xstep.lmbda * rl1
return (obj, dfd, rl1)
def evaluate(self):
"""Evaluate functional value of previous iteration."""
X = mp_Z_Y
Xf = mp_Zf
Df = mp_Df
Sf = mp_Sf
Ef = sl.inner(Df[np.newaxis, ...], Xf,
axis=self.xstep.cri.axisM+1) - Sf
Ef = np.swapaxes(Ef, 0, self.xstep.cri.axisK+1)[0]
dfd = sl.rfl2norm2(Ef, self.xstep.S.shape,
axis=self.xstep.cri.axisN)/2.0
rl1 = np.sum(np.abs(X))
obj = dfd + self.xstep.lmbda*rl1
return (obj, dfd, rl1)
def evaluate(self):
"""Evaluate functional value of previous iteration."""
if self.opt['AccurateDFid']:
D = self.dstep.var_y()
X = self.xstep.var_y()
Df = sl.rfftn(D, self.xstep.cri.Nv, self.xstep.cri.axisN)
Xf = sl.rfftn(X, self.xstep.cri.Nv, self.xstep.cri.axisN)
Sf = self.xstep.Sf
Ef = sl.inner(Df, Xf, axis=self.xstep.cri.axisM) - Sf
dfd = sl.rfl2norm2(Ef, self.xstep.S.shape,
axis=self.xstep.cri.axisN)/2.0
rl1 = np.sum(np.abs(X))
return dict(DFid=dfd, RegL1=rl1, ObjFun=dfd+self.xstep.lmbda*rl1)
else:
return None
def evaluate(self, S, X):
"""Optionally evaluate functional values."""
if self.opt['AccurateDFid']:
cri_s = cr.CSC_ConvRepIndexing(self.getdict(),
S.squeeze(),
dimK=None,
dimN=2)
Df = sl.rfftn(self.D.reshape(cri_s.shpD), cri_s.Nv, cri_s.axisN)
Xf = sl.rfftn(X.reshape(cri_s.shpX), cri_s.Nv, cri_s.axisN)
Sf = sl.rfftn(S.reshape(cri_s.shpS), cri_s.Nv, cri_s.axisN)
Ef = sl.inner(Df, Xf, axis=cri_s.axisM) - Sf
dfd = sl.rfl2norm2(Ef, S.shape, axis=cri_s.axisN) / 2.
rl1 = np.sum(np.abs(X))
evl = dict(DFid=dfd, RegL1=rl1, ObjFun=dfd + self.lmbda * rl1)
else:
evl = None
return evl
def evaluate(self):
"""Evaluate functional value of previous iteration"""
if self.opt['AccurateDFid']:
D = self.getdict(crop=False)
X = self.getcoef()
Df = sl.rfftn(D, self.xstep.cri.Nv, self.xstep.cri.axisN)
Xf = sl.rfftn(X, self.xstep.cri.Nv, self.xstep.cri.axisN)
Sf = self.xstep.Sf
Ef = np.sum(Df * Xf, axis=self.xstep.cri.axisM, keepdims=True) - Sf
dfd = sl.rfl2norm2(
Ef, self.xstep.S.shape, axis=self.xstep.cri.axisN) / 2.0
rl1 = np.sum(np.abs(X))
return dict(DFid=dfd,
RegL1=rl1,
ObjFun=dfd + self.xstep.lmbda * rl1)
else:
return None
def evaluate(self):
"""Evaluate functional value of previous iteration."""
if self.opt['AccurateDFid']:
if self.dmethod == 'fista':
D = self.dstep.getdict(crop=False)
else:
D = self.dstep.var_y()
if self.xmethod == 'fista':
X = self.xstep.getcoef()
else:
X = self.xstep.var_y()
Df = sl.rfftn(D, self.xstep.cri.Nv, self.xstep.cri.axisN)
Xf = sl.rfftn(X, self.xstep.cri.Nv, self.xstep.cri.axisN)
Sf = self.xstep.Sf
Ef = sl.inner(Df, Xf, axis=self.xstep.cri.axisM) - Sf
dfd = sl.rfl2norm2(Ef, self.xstep.S.shape,
axis=self.xstep.cri.axisN) / 2.0
rl1 = np.sum(np.abs(X))
return dict(DFid=dfd, RegL1=rl1,
ObjFun=dfd + self.xstep.lmbda * rl1)
else:
return None
def test_20(self):
x = np.random.randn(16, )
xf = linalg.rfftn(x, axes=(0,))
n1 = np.linalg.norm(x)**2
n2 = linalg.rfl2norm2(xf, xs=x.shape, axis=(0,))
assert np.abs(n1 - n2) < 1e-12
def rsdl(self):
"""Compute fixed point residual in Fourier domain."""
diff = self.Xf - self.Yfprv
return sl.rfl2norm2(diff, self.X.shape, axis=self.cri.axisN)
def test_20(self):
x = np.random.randn(16, )
xf = linalg.rfftn(x, axes=(0,))
n1 = np.linalg.norm(x)**2
n2 = linalg.rfl2norm2(xf, xs=x.shape, axis=(0,))
assert np.abs(n1 - n2) < 1e-12
def rsdl(self):
"""Compute fixed point residual in Fourier domain."""
diff = self.Xf - self.Yfprv
return sl.rfl2norm2(diff, self.X.shape, axis=self.cri.axisN)
