def setup_solver_pdhg(self):
x, y = self.x.vars(named=True), self.y.vars(named=True)
c = self.constvars
imagedims = c['imagedims']
n_image = c['n_image']
d_image = c['d_image']
l_labels = c['l_labels']
m_gradients = c['m_gradients']
s_manifold = c['s_manifold']
l_shm = c['l_shm']
dataterm = BndSSD(c['f1'], c['f2'], vol=c['b'], mask=c['inpaint_nloc'])
self.pdhg_G = SplitSum([
PositivityFct(x['u1']['size']), # \delta_{u1 >= 0}
dataterm, # 0.5*|max(0, f1 - u2)|^2 + 0.5*|max(0, u2 - f2)|^2
ZeroFct(x['v']['size']), # 0
ZeroFct(x['w']['size']) # 0
])
GradOp = GradientOp(imagedims, l_labels, weights=c['b'])
PBLinOp = IndexedMultAdj(l_labels, d_image * n_image, c['P'], c['B'])
AMult = MatrixMultRBatched(n_image * d_image, c['A'])
bMult = MatrixMultR(n_image, c['b_precond'] * c['b'][:, None])
YMult = MatrixMultR(n_image, c['Y'], trans=True)
YMMult = MatrixMultR(n_image, c['YM'], trans=True)
m_u = ScaleOp(x['u1']['size'], -1)
self.pdhg_linop = BlockOp([
[GradOp, 0, 0, PBLinOp], # p = diag(b)Du1 - P'B'w
[0, 0, 0, AMult], # g = A'w
[bMult, 0, 0, 0], # q0 = <b,u1>
[m_u, 0, YMult, 0], # q1 = Yv - u1
[0, m_u, YMMult, 0] # q2 = YMv - u2
])
l1norms = L1Norms(m_gradients * n_image, (d_image, s_manifold),
c['lbd'], self.gradnorm)
self.pdhg_F = SplitSum([
IndicatorFct(y['p']['size']), # \delta_{p = 0}
l1norms, # lbd*\sum_ji |g[j,i,:,:]|_nuc
IndicatorFct(y['q0']['size'],
c1=c['b_precond']), # \delta_{q0 = 1}
IndicatorFct(x['u1']['size']), # \delta_{q1 = 0}
IndicatorFct(x['u1']['size']) # \delta_{q2 = 0}
])
def setup_solver_pdhg(self):
x, y = self.x.vars(named=True), self.y.vars(named=True)
c = self.constvars
imagedims = c['imagedims']
n_image = c['n_image']
d_image = c['d_image']
l_labels = c['l_labels']
m_gradients = c['m_gradients']
s_manifold = c['s_manifold']
l_shm = c['l_shm']
dataterm = SSD(c['f'], vol=c['b'], mask=c['inpaint_nloc'])
self.pdhg_G = SplitSum([
PositivityFct(x['u1']['size']), # \delta_{u1 >= 0}
dataterm, # 0.5*<u2-f,u2-f>
ZeroFct(x['v']['size']), # 0
ZeroFct(x['w']['size']) # 0
])
GradOp = GradientOp(imagedims, l_shm)
GMult = TangledMatrixMultR(n_image * d_image, c['G'][:, :, None, :])
bMult = MatrixMultR(n_image, c['b_precond'] * c['b'][:, None])
YMult = MatrixMultR(n_image, c['Y'], trans=True)
YMMult = MatrixMultR(n_image, c['YM'], trans=True)
m_u = ScaleOp(x['u1']['size'], -1)
m_w = ScaleOp(x['w']['size'], -1)
self.pdhg_linop = BlockOp([
[0, 0, GradOp, GMult], # p = Dv + G'w
[0, 0, 0, m_w], # g = -w
[bMult, 0, 0, 0], # q0 = <b,u1>
[m_u, 0, YMult, 0], # q1 = Yv - u1
[0, m_u, YMMult, 0] # q2 = YMv - u2
])
l1norms = L1Norms(m_gradients * n_image, (d_image, s_manifold),
c['lbd'], self.gradnorm)
self.pdhg_F = SplitSum([
IndicatorFct(y['p']['size']), # \delta_{p = 0}
l1norms, # lbd*\sum_ji |g[j,i,:,:]|_nuc
IndicatorFct(y['q0']['size'],
c1=c['b_precond']), # \delta_{q0 = 1}
IndicatorFct(x['u1']['size']), # \delta_{q1 = 0}
IndicatorFct(x['u1']['size']) # \delta_{q2 = 0}
])
def setup_solver_pdhg(self):
x, y = self.x.vars(named=True), self.y.vars(named=True)
c = self.constvars
imagedims = c['imagedims']
n_image = c['n_image']
d_image = c['d_image']
l_labels = c['l_labels']
l_shm = c['l_shm']
self.pdhg_G = SplitSum([
PositivityFct(x['u1']['size']), # \delta_{u1 >= 0}
ZeroFct(x['u1']['size']), # 0
ZeroFct(x['v']['size']) # 0
])
GradOp = GradientOp(imagedims, l_shm)
bMult = MatrixMultR(n_image, c['b_precond'] * c['b'][:, None])
YMult = MatrixMultR(n_image, c['Y'], trans=True)
YMMult = MatrixMultR(n_image, c['YM'], trans=True)
m_u = ScaleOp(x['u1']['size'], -1)
dbMult = DiagMatrixMultR(n_image, c['b'])
mdbMult = DiagMatrixMultR(n_image, -c['b'])
self.pdhg_linop = BlockOp([
[0, 0, GradOp], # p = Dv
[bMult, 0, 0], # q0 = <b,u1>
[m_u, 0, YMult], # q1 = Yv - u1
[0, m_u, YMMult], # q2 = YMv - u2
[0, mdbMult, 0], # q3 = -diag(b) u2
[0, dbMult, 0] # q4 = diag(b) u2
])
l1norms = L1Norms(n_image, (d_image, l_shm), c['lbd'], "frobenius")
LowerBoundFct = MaxFct(np.einsum('ik,k->ik', c['f1'], -c['b']))
UpperBoundFct = MaxFct(np.einsum('ik,k->ik', c['f2'], c['b']))
self.pdhg_F = SplitSum([
l1norms, # lbd*\sum_i |p[i,:,:]|_2
IndicatorFct(y['q0']['size'],
c1=c['b_precond']), # \delta_{q0 = 1}
IndicatorFct(x['u1']['size']), # \delta_{q1 = 0}
IndicatorFct(x['u1']['size']), # \delta_{q2 = 0}
LowerBoundFct, # |max(0, q3 + diag(b)f1)|_1
UpperBoundFct # |max(0, q4 - diag(b)f2)|_1
])
def setup_solver(self, *args):
imagedims = self.data.imagedims
N_image = self.data.N_image
L_labels = self.data.L_labels
M_tris = self.data.M_tris
s_gamma = self.data.s_gamma
d_image = self.data.d_image
Id_w2 = np.zeros((s_gamma+1,d_image*s_gamma+1), order='C')
Id_w2[-1,-1] = 1.0
Adext = np.zeros((M_tris,s_gamma,d_image*s_gamma+1), order='C')
Adext[:,:,:-1] = np.tile(self.data.Ad, (1,1,d_image))
# Ab (M_tris, s_gamma+1, s_gamma+1)
Ab_mats = -np.ones((M_tris, s_gamma+1, s_gamma+1),
dtype=np.float64, order='C')
Ab_mats[:,:,0:-1] = self.data.T[self.data.P]
Ab_mats[:] = np.linalg.inv(Ab_mats)
self.linblocks.update({
'PAbTri': IndexedMultAdj(L_labels, N_image, self.data.P, Ab_mats),
'Grad': GradientOp(imagedims, L_labels, scheme=self.fdscheme),
'PB': IndexedMultAdj(L_labels, d_image*N_image, self.data.P, self.data.B),
'Ad': MatrixMultRBatched(N_image*d_image, self.data.Ad),
'Adext': MatrixMultRBatched(N_image, Adext),
'Id_w2': MatrixMultR(M_tris*N_image, Id_w2),
})
SublabelModel.setup_solver(self, *args)
def setup_dataterm_blocks(self):
if hasattr(self, 'epifct') or hasattr(self, 'rho'):
return
N_image = self.data.N_image
L_labels = self.data.L_labels
M_tris = self.data.M_tris
s_gamma = self.data.s_gamma
P = self.data.P
if self.data.R.shape[-1] == s_gamma + 1:
logging.info("Setup for model without sublabels...")
R = self.data.R.reshape(M_tris, N_image, s_gamma + 1)
self.rho = np.zeros((N_image, L_labels), order='C')
for j in range(M_tris):
for m in range(s_gamma + 1):
self.rho[:, P[j, m]] = R[j, :, m]
self.rho = self.rho.ravel()
else:
logging.info("Setup for sublabel-accurate model...")
self.epifct = EpigraphSupp(self.data.Rbase, self.data.Rfaces,
self.data.Qbary, self.data.Sbary,
self.data.R)
# Ab (M_tris, s_gamma+1, s_gamma+1)
Ab = np.zeros((M_tris, s_gamma + 1, s_gamma + 1),
dtype=np.float64,
order='C')
Ab[:] = np.eye(s_gamma + 1)[None]
Ab[..., -1] = -1
self.linblocks['PAb'] = IndexedMultAdj(L_labels, N_image, P, Ab)
self.linblocks.update({
'S':
MatrixMultR(N_image, np.ones((L_labels, 1), order='C')),
})
def setup_solver(self, *args):
imagedims = self.data.imagedims
N_image = self.data.N_image
L_labels = self.data.L_labels
d_image = self.data.d_image
M_tris = self.data.M_tris
s_gamma = self.data.s_gamma
Id_w2 = np.zeros((s_gamma + 1, d_image * s_gamma + 1), order='C')
Id_w2[-1, -1] = 1.0
Adext = np.zeros((M_tris, d_image * s_gamma, d_image * s_gamma + 1),
order='C')
Adext[:, :, :-1] = np.kron(np.eye(d_image), self.data.Ad)
self.linblocks.update({
'Grad':
GradientOp(imagedims, L_labels, scheme=self.fdscheme),
'PB':
IndexedMultAdj(L_labels, d_image * N_image, self.data.P,
self.data.B),
'Adext':
MatrixMultRBatched(N_image, Adext),
'Id_w2':
MatrixMultR(M_tris * N_image, Id_w2),
})
SublabelModel.setup_solver(self, *args)
def setup_solver_pdhg(self):
x, y = self.x.vars(named=True), self.y.vars(named=True)
c = self.constvars
imagedims = c['imagedims']
n_image = c['n_image']
d_image = c['d_image']
l_labels = c['l_labels']
l_shm = c['l_shm']
dataterm = BndSSD(c['f1'], c['f2'], vol=c['b'], mask=c['inpaint_nloc'])
self.pdhg_G = SplitSum([
PositivityFct(x['u1']['size']), # \delta_{u1 >= 0}
dataterm, # 0.5*|max(0, f1 - u2)|^2 + 0.5*|max(0, u2 - f2)|^2
ZeroFct(x['v']['size']) # 0
])
GradOp = GradientOp(imagedims, l_shm)
bMult = MatrixMultR(n_image, c['b_precond'] * c['b'][:, None])
YMult = MatrixMultR(n_image, c['Y'], trans=True)
YMMult = MatrixMultR(n_image, c['YM'], trans=True)
m_u = ScaleOp(x['u1']['size'], -1)
self.pdhg_linop = BlockOp([
[0, 0, GradOp], # p = Dv
[bMult, 0, 0], # q0 = <b,u1>
[m_u, 0, YMult], # q1 = Yv - u1
[0, m_u, YMMult] # q2 = YMv - u2
])
l1norms = L1Norms(n_image, (d_image, l_shm), c['lbd'], "frobenius")
self.pdhg_F = SplitSum([
l1norms, # lbd*\sum_i |p[i,:,:]|_2
IndicatorFct(y['q0']['size'],
c1=c['b_precond']), # \delta_{q0 = 1}
IndicatorFct(x['u1']['size']), # \delta_{q1 = 0}
IndicatorFct(x['u1']['size']) # \delta_{q2 = 0}
])
def setup_dataterm_blocks(self):
if hasattr(self, 'epifct'):
return
N_image = self.data.N_image
L_labels = self.data.L_labels
M_tris = self.data.M_tris
s_gamma = self.data.s_gamma
self.epifct = EpigraphSupp(self.data.Rbase, self.data.Rfaces,
self.data.Qbary, self.data.Sbary,
self.data.R)
# Ab (M_tris, s_gamma+1, s_gamma+1)
Ab_mats = np.zeros((M_tris, s_gamma + 1, s_gamma + 1),
dtype=np.float64,
order='C')
Ab_mats[:] = np.eye(s_gamma + 1)[None]
Ab_mats[..., -1] = -1
self.linblocks.update({
'PAb':
IndexedMultAdj(L_labels, N_image, self.data.P, Ab_mats),
'S':
MatrixMultR(N_image, np.ones((L_labels, 1), order='C')),
})
def setup_solver_pdhg(self):
x, y = self.x.vars(named=True), self.y.vars(named=True)
c = self.constvars
imagedims = c['imagedims']
n_image = c['n_image']
d_image = c['d_image']
l_labels = c['l_labels']
m_gradients = c['m_gradients']
s_manifold = c['s_manifold']
GradOp = GradientOp(imagedims, l_labels, weights=c['b'])
PBLinOp = IndexedMultAdj(l_labels, d_image * n_image, c['P'], c['B'])
AMult = MatrixMultRBatched(n_image * d_image, c['A'])
bMult = MatrixMultR(n_image, c['b_precond'] * c['b'][:, None])
l1norms = L1Norms(m_gradients * n_image, (d_image, s_manifold),
c['lbd'], self.gradnorm)
if self.dataterm == "W1":
self.pdhg_G = SplitSum([
PositivityFct(x['u']['size']), # \delta_{u >= 0}
ZeroFct(x['w']['size']), # 0
ZeroFct(x['w0']['size']), # 0
])
PBLinOp0 = IndexedMultAdj(l_labels, n_image, c['P'], c['B'])
AMult0 = MatrixMultRBatched(n_image, c['A'])
bMult0 = DiagMatrixMultR(n_image, c['b'])
self.pdhg_linop = BlockOp([
[GradOp, PBLinOp, 0], # p = diag(b)Du - P'B'w
[0, AMult, 0], # g = A'w
[bMult, 0, 0], # q = <b,u>
[bMult0, 0, PBLinOp0], # p0 = diag(b) u - P'B'w0
[0, 0, AMult0] # g0 = A'w0
])
diag_b_f = np.einsum('ik,k->ik', self.f, c['b'])
dataterm = ConstrainFct(c['inpaint_nloc'], diag_b_f)
l1norms0 = L1Norms(m_gradients * n_image, (1, s_manifold), 1.0,
"frobenius")
self.pdhg_F = SplitSum([
IndicatorFct(y['p']['size']), # \delta_{p = 0}
l1norms, # lbd*\sum_ji |g[j,i,:,:]|_nuc
IndicatorFct(y['q']['size'],
c1=c['b_precond']), # \delta_{q = 1}
dataterm, # \delta_{p0 = diag(b)f}
l1norms0, # \sum_ji |g0[j,i,:]|_2
])
elif self.dataterm == "quadratic":
dataterm = PosSSD(self.f, vol=c['b'], mask=c['inpaint_nloc'])
self.pdhg_G = SplitSum([
dataterm, # 0.5*<u-f,u-f>_b + \delta_{u >= 0}
ZeroFct(x['w']['size']), # 0
])
self.pdhg_linop = BlockOp([
[GradOp, PBLinOp], # p = diag(b)Du - P'B'w
[0, AMult], # g = A'w
[bMult, 0], # q = <b,u>
])
self.pdhg_F = SplitSum([
IndicatorFct(y['p']['size']), # \delta_{p = 0}
l1norms, # lbd*\sum_ji |g[j,i,:,:]|_nuc
IndicatorFct(y['q']['size'],
c1=c['b_precond']), # \delta_{q = 1}
])