def setup_solver_pdhg(self):
x, y = self.x.vars(named=True), self.y.vars(named=True)
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
PAbOp = self.linblocks['PAb']
S_u_k = self.linblocks['S']
GradOp = self.linblocks['Grad']
PBLinOp = self.linblocks['PB']
AdMult = self.linblocks['Adext']
Id_w2 = self.linblocks['Id_w2']
if self.alph < np.inf:
etahat = HuberPerspective(M_tris * N_image,
s_gamma * d_image,
lbd=self.lbd,
alph=self.alph)
else:
etahat = QuadEpiSupp(M_tris * N_image,
s_gamma * d_image,
a=self.lbd)
Id_u = IdentityOp(x['u']['size'])
Id_w12 = IdentityOp(x['w12']['size'])
if self.data.constraints is not None:
constrmask, constru = self.data.constraints
constru_lifted = self.data.mfd.embed_barycentric(constru)[1]
Gu = ConstrainFct(constrmask, constru_lifted)
else:
Gu = PositivityFct(x['u']['size'])
self.pdhg_G = SplitSum([
Gu, # \delta_{u >= 0} or constraints
ZeroFct(x['w12']['size']), # 0
ZeroFct(x['w']['size']), # 0
])
self.pdhg_F = SplitSum([
IndicatorFct(y['p']['size']), # \delta_{p = 0}
IndicatorFct(y['q']['size']), # \delta_{q = 0}
self.epifct, # \max_{v \in epi(rho*)} <v12,v>
IndicatorFct(y['v3']['size'], c1=1), # \delta_{v3^i = 1}
etahat, # 0.5*lbd*\sum_ji |g1[j,i]|^2/|g2[j,i]|
])
self.pdhg_linop = BlockOp([
[GradOp, 0, PBLinOp], # p = Du - P'B'w
[Id_u, PAbOp, 0], # q = u - P'Ab'w12
[0, Id_w12, 0], # v12 = w12
[S_u_k, 0, 0], # v3^i = sum_k u[i,k]
[0, Id_w2, AdMult], # g12 = (Ad'w, w2)
])
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']
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']
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_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_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}
])
def setup_solver_pdhg(self):
x, y = self.x.vars(named=True), self.y.vars(named=True)
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
PAbOp = self.linblocks['PAbTri']
S_u_k = self.linblocks['S']
GradOp = self.linblocks['Grad']
PBLinOp = self.linblocks['PB']
AdMult = self.linblocks['Ad']
shift = np.tile(self.data.data_b, (M_tris,1,1)).reshape((-1, s_gamma))
c = 0.5*(shift**2).sum(axis=-1)
epifct1 = QuadEpiSupp(M_tris*N_image, s_gamma, b=-shift, c=c)
epifct2 = EpigraphSupp(np.ones((N_image, L_labels), dtype=bool),
[[np.arange(s_gamma+1)[None]]*M_tris]*N_image,
self.data.P, self.data.T, np.zeros((N_image, L_labels)))
Id_u = IdentityOp(x['u']['size'])
Id_w12 = IdentityOp(x['w12']['size'])
if self.data.constraints is not None:
constrmask, constru = self.data.constraints
constru_lifted = self.data.mfd.embed_barycentric(constru)[1]
Gu = ConstrainFct(constrmask, constru_lifted)
else:
Gu = PositivityFct(x['u']['size'])
self.pdhg_G = SplitSum([
Gu, # \delta_{u >= 0} or constraints
ZeroFct(x['w12']['size']), # 0
ZeroFct(x['w']['size']), # 0
])
F_summands = [
IndicatorFct(y['p']['size']), # \delta_{p = 0}
IndicatorFct(y['q']['size']), # \delta_{q = 0}
epifct1, # -0.5*v2a*|v1a/v2a + b|^2
epifct2, # \max_{v \in Delta} <v12b,v>
IndicatorFct(y['v3']['size'], c1=1), # \delta_{v3^i = 1}
]
op_blocks = [
[GradOp, 0, PBLinOp], # p = Du - P'B'w
[ Id_u, PAbOp, 0], # q = u - P'Ab'w12
[ 0, Id_w12, 0], # v12a = w12
[ 0, Id_w12, 0], # v12b = w12
[ S_u_k, 0, 0], # v3^i = sum_k u[i,k]
]
if self.regularizer == "tv":
l1norms = L1Norms(M_tris*N_image, (d_image, s_gamma), self.lbd, "nuclear")
F_summands.append(l1norms) # lbd*\sum_ji |g[j,i,:,:]|_nuc
op_blocks.append([ 0, 0, AdMult]) # g = A'w
elif self.regularizer == "quadratic":
if self.alph < np.inf:
etahat = HuberPerspective(M_tris*N_image, s_gamma*d_image,
lbd=self.lbd, alph=self.alph)
else:
etahat = QuadEpiSupp(M_tris*N_image, s_gamma*d_image, a=self.lbd)
F_summands.append(etahat) # 0.5*lbd*\sum_ji |g1[j,i]|^2/|g2[j,i]|
AdMult = self.linblocks['Adext']
Id_w2 = self.linblocks['Id_w2']
op_blocks.append([ 0, Id_w2, AdMult]) # g12 = (Ad'w, w2)
self.pdhg_F = SplitSum(F_summands)
self.pdhg_linop = BlockOp(op_blocks)
def setup_solver_pdhg(self):
x, y = self.x.vars(named=True), self.y.vars(named=True)
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
S_u_k = self.linblocks['S']
GradOp = self.linblocks['Grad']
PBLinOp = self.linblocks['PB']
AdMult = self.linblocks['Ad']
l1norms = L1Norms(M_tris * N_image, (d_image, s_gamma), self.lbd,
"nuclear")
Id_u = IdentityOp(x['u']['size'])
if self.data.constraints is not None:
constrmask, constru = self.data.constraints
constru_lifted = self.data.mfd.embed_barycentric(constru)[1]
Gu = ConstrainFct(constrmask, constru_lifted)
else:
Gu = PositivityFct(x['u']['size'])
if hasattr(self, 'epifct'):
PAbOp = self.linblocks['PAb']
Id_w12 = IdentityOp(x['w12']['size'])
G_summands = [
Gu, # \delta_{u >= 0} or constraints
ZeroFct(x['w12']['size']), # 0
ZeroFct(x['w']['size']), # 0
]
F_summands = [
IndicatorFct(y['p']['size']), # \delta_{p = 0}
IndicatorFct(y['q']['size']), # \delta_{q = 0}
self.epifct, # \max_{v \in epi(rho*)} <v12,v>
IndicatorFct(y['v3']['size'], c1=1), # \delta_{v3^i = 1}
l1norms, # lbd*\sum_ji |g[j,i,:,:]|_nuc
]
op_blocks = [
[GradOp, 0, PBLinOp], # p = Du - P'B'w
[Id_u, PAbOp, 0], # q = u - P'Ab'w12
[0, Id_w12, 0], # v12 = w12
[S_u_k, 0, 0], # v3^i = sum_k u[i,k]
[0, 0, AdMult], # g = A'w
]
else:
G_summands = [
Gu, # \delta_{u >= 0} or constraints
ZeroFct(x['w']['size']), # 0
]
F_summands = [
IndicatorFct(y['p']['size']), # \delta_{p = 0}
AffineFct(y['q']['size'], c=self.rho), # <q,rho>
IndicatorFct(y['v3']['size'], c1=1), # \delta_{v3^i = 1}
l1norms, # lbd*\sum_ji |g[j,i,:,:]|_nuc
]
op_blocks = [
[GradOp, PBLinOp], # p = Du - P'B'w
[Id_u, 0], # q = u
[S_u_k, 0], # v3^i = sum_k u[i,k]
[0, AdMult], # g = A'w
]
self.pdhg_G = SplitSum(G_summands)
self.pdhg_F = SplitSum(F_summands)
self.pdhg_linop = BlockOp(op_blocks)