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 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 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 = dot(self.B,
inner(self.Df, self.obfn_fvarf(), axis=self.cri.axisM),
axis=self.cri.axisC)
Ef = DXBf - self.Sf
return 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 rfl2norm2(Ef, self.S.shape, axis=self.cri.axisN) / 2.0
def obfn_dfd(self):
"""Compute data fidelity term."""
if self.opt['DatFidNoDC']:
Sf = self.Sf.copy()
if self.cri.dimN == 1:
Sf[0] = 0
else:
Sf[0, 0] = 0
else:
Sf = self.Sf
Ef = inner(self.Df, self.obfn_fvarf(), axis=self.cri.axisM) - Sf
return rfl2norm2(Ef, self.S.shape, axis=self.cri.axisN) / 2.0
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 = 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 = 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']:
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 = rfftn(D, self.xstep.cri.Nv, self.xstep.cri.axisN)
Xf = rfftn(X, self.xstep.cri.Nv, self.xstep.cri.axisN)
Sf = self.xstep.Sf
Ef = inner(Df, Xf, axis=self.xstep.cri.axisM) - Sf
dfd = 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_02(self):
x = np.random.randn(16, )
xf = fft.rfftn(x, axes=(0, ))
n1 = np.linalg.norm(x)**2
n2 = fft.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 rfl2norm2(diff, self.X.shape, axis=self.cri.axisN)
