def compute_loss(self,z,y_, **kwargs):
islices = kwargs.pop('islices',None)
if islices is not None:
mask = [self.immask[islices].ravel() for i in range(len(self.labelset))]
else:
mask = self.mask
if np.sum(y_<-1e-6) > 0:
miny = np.min(y_)
logger.warning('negative (<-1e-6) values in y_. min = {:.3}'.format(miny))
#self.use_ideal_loss = True
#if self.use_ideal_loss:
if self.loss_type in ['ideal', 'none']:
loss = loss_functions.ideal_loss(z,y_,mask=mask)
elif self.loss_type=='squareddiff':
loss = loss_functions.anchor_loss(z,y_,mask=mask)
elif self.loss_type=='laplacian':
loss = loss_functions.laplacian_loss(z,y_,mask=mask)
elif self.loss_type=='linear':
loss = loss_function.linear_loss(z,y,mask=mask)
else:
raise Exception('wrong loss type')
sys.exit(1)
return loss*self.loss_factor
def compute_loss(self, z, y_, **kwargs):
islices = kwargs.pop('islices', None)
if islices is not None:
mask = [
self.immask[islices].ravel() for i in range(len(self.labelset))
]
else:
mask = self.mask
if np.sum(y_ < -1e-6) > 0:
miny = np.min(y_)
logger.warning(
'negative (<-1e-6) values in y_. min = {:.3}'.format(miny))
#self.use_ideal_loss = True
#if self.use_ideal_loss:
if self.loss_type in ['ideal', 'none']:
loss = loss_functions.ideal_loss(z, y_, mask=mask)
elif self.loss_type == 'squareddiff':
loss = loss_functions.anchor_loss(z, y_, mask=mask)
elif self.loss_type == 'laplacian':
loss = loss_functions.laplacian_loss(z, y_, mask=mask)
elif self.loss_type == 'linear':
loss = loss_function.linear_loss(z, y, mask=mask)
else:
raise Exception('wrong loss type')
sys.exit(1)
return loss * self.loss_factor
def compute_losses(z,y,mask):
## loss 0 : 1 - Dice(y,z)
loss0 = loss_functions.ideal_loss(z,y,mask=mask)
logger.info('Tloss = {}'.format(loss0))
## loss2: squared difference with ztilde
loss1 = loss_functions.anchor_loss(z,y,mask=mask)
logger.info('SDloss = {}'.format(loss1))
## loss3: laplacian loss
loss2 = loss_functions.laplacian_loss(z,y,mask=mask)
logger.info('LAPloss = {}'.format(loss2))
## loss4: linear loss
loss3 = loss_functions.linear_loss(z,y,mask=mask)
logger.info('LINloss = {}'.format(loss3))
return loss0, loss1, loss2, loss3
def compute_losses(z, y, mask):
## loss 0 : 1 - Dice(y,z)
loss0 = loss_functions.ideal_loss(z, y, mask=mask)
logger.info('Tloss = {}'.format(loss0))
## loss2: squared difference with ztilde
loss1 = loss_functions.anchor_loss(z, y, mask=mask)
logger.info('SDloss = {}'.format(loss1))
## loss3: laplacian loss
loss2 = loss_functions.laplacian_loss(z, y, mask=mask)
logger.info('LAPloss = {}'.format(loss2))
## loss4: linear loss
loss3 = loss_functions.linear_loss(z, y, mask=mask)
logger.info('LINloss = {}'.format(loss3))
return loss0, loss1, loss2, loss3
def run_svm_inference(self,test,w, test_dir):
logger.info('running inference on: {}'.format(test))
## normalize w
# w = w / np.sqrt(np.dot(w,w))
strw = ' '.join('{:.3}'.format(val) for val in np.asarray(w)*self.psi_scale)
logger.debug('scaled w=[{}]'.format(strw))
weights_laplacians = np.asarray(w)[self.indices_laplacians]
weights_laplacians_h = np.asarray(self.hand_tuned_w)[self.indices_laplacians]
weights_priors = np.asarray(w)[self.indices_priors]
weights_priors_h = np.asarray(self.hand_tuned_w)[self.indices_priors]
## segment test image with trained w
'''
def meta_weight_functions(im,i,j,_w):
data = 0
for iwf,wf in enumerate(self.laplacian_functions):
_data = wf(im,i,j)
data += _w[iwf]*_data
return data
weight_function = lambda im: meta_weight_functions(im,i,j,weights_laplacians)
weight_function_h = lambda im: meta_weight_functions(im,i,j,weights_laplacians_h)
'''
weight_function = MetaLaplacianFunction(
weights_laplacians,
self.laplacian_functions)
weight_function_h = MetaLaplacianFunction(
weights_laplacians_h,
self.laplacian_functions)
## load images and ground truth
file_seg = self.dir_reg + test + 'seg.hdr'
file_im = self.dir_reg + test + 'gray.hdr'
im = io_analyze.load(file_im)
seg = io_analyze.load(file_seg)
seg.flat[~np.in1d(seg.ravel(),self.labelset)] = self.labelset[0]
nim = im/np.std(im) # normalize image by std
## test training data ?
inference_train = True
if inference_train:
train_ims, train_segs, train_metas = self.training_set
for tim, tz, tmeta in zip(train_ims, train_segs, train_metas):
## retrieve metadata
islices = tmeta.pop('islices',None)
imask = tmeta.pop('imask', None)
iimask = tmeta.pop('iimask',None)
if islices is not None:
tseeds = self.seeds[islices]
tprior = {
'data': np.asarray(self.prior['data'])[:,iimask],
'imask': imask,
'variance': np.asarray(self.prior['variance'])[:,iimask],
'labelset': self.labelset,
}
if 'intensity' in self.prior:
tprior['intensity'] = self.prior['intensity']
else:
tseeds = self.seeds
tprior = self.prior
## prior
tseg = self.labelset[np.argmax(tz, axis=0)].reshape(tim.shape)
tanchor_api = MetaAnchor(
tprior,
self.prior_functions,
weights_priors,
image=tim,
)
tsol,ty = rwsegment.segment(
tim,
tanchor_api,
seeds=tseeds,
weight_function=weight_function,
**self.rwparams_inf
)
## compute Dice coefficient
tdice = compute_dice_coef(tsol, tseg, labelset=self.labelset)
logger.info('Dice coefficients for train: \n{}'.format(tdice))
nlabel = len(self.labelset)
tflatmask = np.zeros(ty.shape, dtype=bool)
tflatmask[:,imask] = True
loss0 = loss_functions.ideal_loss(tz,ty,mask=tflatmask)
logger.info('Tloss = {}'.format(loss0))
## loss2: squared difference with ztilde
loss1 = loss_functions.anchor_loss(tz,ty,mask=tflatmask)
logger.info('SDloss = {}'.format(loss1))
## loss3: laplacian loss
loss2 = loss_functions.laplacian_loss(tz,ty,mask=tflatmask)
logger.info('LAPloss = {}'.format(loss2))
tanchor_api_h = MetaAnchor(
tprior,
self.prior_functions,
weights_priors_h,
image=tim,
)
tsol,ty = rwsegment.segment(
tim,
tanchor_api_h,
seeds=tseeds,
weight_function=weight_function_h,
**self.rwparams_inf
)
## compute Dice coefficient
tdice = compute_dice_coef(tsol, tseg, labelset=self.labelset)
logger.info('Dice coefficients for train (hand-tuned): \n{}'.format(tdice))
loss0 = loss_functions.ideal_loss(tz,ty,mask=tflatmask)
logger.info('Tloss (hand-tuned) = {}'.format(loss0))
## loss2: squared difference with ztilde
loss1 = loss_functions.anchor_loss(tz,ty,mask=tflatmask)
logger.info('SDloss (hand-tuned) = {}'.format(loss1))
## loss3: laplacian loss
loss2 = loss_functions.laplacian_loss(tz,ty,mask=tflatmask)
logger.info('LAPloss (hand-tuned) = {}'.format(loss2))
break
## prior
anchor_api = MetaAnchor(
self.prior,
self.prior_functions,
weights_priors,
image=nim,
)
sol,y = rwsegment.segment(
nim,
anchor_api,
seeds=self.seeds,
weight_function=weight_function,
**self.rwparams_inf
)
## compute Dice coefficient
dice = compute_dice_coef(sol, seg,labelset=self.labelset)
logger.info('Dice coefficients: \n{}'.format(dice))
## objective
en_rw = rwsegment.energy_rw(
nim, y, seeds=self.seeds,weight_function=weight_function, **self.rwparams_inf)
en_anchor = rwsegment.energy_anchor(
nim, y, anchor_api, seeds=self.seeds, **self.rwparams_inf)
obj = en_rw + en_anchor
logger.info('Objective = {:.3}'.format(obj))
## compute losses
z = seg.ravel()==np.c_[self.labelset]
mask = self.seeds < 0
flatmask = mask.ravel()*np.ones((len(self.labelset),1))
## loss 0 : 1 - Dice(y,z)
loss0 = loss_functions.ideal_loss(z,y,mask=flatmask)
logger.info('Tloss = {}'.format(loss0))
## loss2: squared difference with ztilde
loss1 = loss_functions.anchor_loss(z,y,mask=flatmask)
logger.info('SDloss = {}'.format(loss1))
## loss3: laplacian loss
loss2 = loss_functions.laplacian_loss(z,y,mask=flatmask)
logger.info('LAPloss = {}'.format(loss2))
## loss4: linear loss
loss3 = loss_functions.linear_loss(z,y,mask=flatmask)
logger.info('LINloss = {}'.format(loss3))
## saving
if self.debug:
pass
elif self.isroot:
outdir = self.dir_inf + test_dir
logger.info('saving data in: {}'.format(outdir))
if not os.path.isdir(outdir):
os.makedirs(outdir)
#io_analyze.save(outdir + 'im.hdr',im.astype(np.int32))
#np.save(outdir + 'y.npy',y)
#io_analyze.save(outdir + 'sol.hdr',sol.astype(np.int32))
np.savetxt(outdir + 'objective.txt', [obj])
np.savetxt(
outdir + 'dice.txt',
np.c_[dice.keys(),dice.values()],fmt='%d %f')
f = open(outdir + 'losses.txt', 'w')
f.write('ideal_loss\t{}\n'.format(loss0))
f.write('anchor_loss\t{}\n'.format(loss1))
f.write('laplacian_loss\t{}\n'.format(loss2))
f.close()
def compute_approximate_aci(self, w,x,z,y0,**kwargs):
logger.info("using approximate aci (Danny's)")
islices = kwargs.pop('islices',None)
imask = kwargs.pop('imask',None)
iimask = kwargs.pop('iimask',None)
if islices is not None:
seeds = self.seeds[islices]
mask = [self.immask[islices].ravel() for i in range(len(self.labelset))]
prior = {
'data': np.asarray(self.prior['data'])[:,iimask],
'imask': imask,
'variance': np.asarray(self.prior['variance'])[:,iimask],
'labelset': self.labelset,
}
if 'intensity' in self.prior: prior['intensity'] = self.prior['intensity']
else:
mask = self.mask
seeds = self.seeds
prior = self.prior
weight_function = MetaLaplacianFunction(
np.asarray(w)[self.indices_laplacians],
self.laplacian_functions,
)
## combine all prior models
anchor_api = MetaAnchor(
prior=prior,
prior_models=self.prior_models,
prior_weights=np.asarray(w)[self.indices_priors],
image=x,
)
class GroundTruthAnchor(object):
def __init__(self, anchor_api, gt, gt_weights):
self.anchor_api = anchor_api
self.gt = gt
self.gt_weights = gt_weights
def get_labelset(self):
return self.anchor_api.get_labelset()
def get_anchor_and_weights(self, D, indices):
anchor, weights = self.anchor_api.get_anchor_and_weights(D,indices)
gt_weights = self.gt_weights[:,indices]
gt = self.gt[:,indices]
new_weights = weights + gt_weights
new_anchor = (anchor * weights + gt*gt_weights) / new_weights
return new_anchor, new_weights
self.approx_aci_maxiter = 200
self.approx_aci_maxstep = 1e-2
z_weights = np.zeros(np.asarray(z).shape)
z_label = np.argmax(z,axis=0)
for i in range(self.approx_aci_maxiter):
logger.debug("approx aci, iter={}".format(i))
## add ground truth to anchor api
modified_api = GroundTruthAnchor(anchor_api, z, z_weights)
## inference
y_ = rwsegment.segment(
x,
modified_api,
seeds=seeds,
weight_function=weight_function,
return_arguments=['y'],
**self.rwparams
)
## loss
#loss = self.compute_loss(z,y_, islices=islices)
loss = loss_functions.ideal_loss(z,y_,mask=mask)
logger.debug('loss = {}'.format(loss))
if loss < 1e-8:
break
## uptade weights
delta = np.max(y_ - y_[z_label, np.arange(y_.shape[1])], axis=0)
delta = np.clip(delta, 0, self.approx_aci_maxstep)
z_weights += delta
return y_
def run_svm_inference(self, test, w, test_dir):
logger.info('running inference on: {}'.format(test))
## normalize w
# w = w / np.sqrt(np.dot(w,w))
strw = ' '.join('{:.3}'.format(val)
for val in np.asarray(w) * self.psi_scale)
logger.debug('scaled w=[{}]'.format(strw))
weights_laplacians = np.asarray(w)[self.indices_laplacians]
weights_laplacians_h = np.asarray(
self.hand_tuned_w)[self.indices_laplacians]
weights_priors = np.asarray(w)[self.indices_priors]
weights_priors_h = np.asarray(self.hand_tuned_w)[self.indices_priors]
## segment test image with trained w
'''
def meta_weight_functions(im,i,j,_w):
data = 0
for iwf,wf in enumerate(self.laplacian_functions):
_data = wf(im,i,j)
data += _w[iwf]*_data
return data
weight_function = lambda im: meta_weight_functions(im,i,j,weights_laplacians)
weight_function_h = lambda im: meta_weight_functions(im,i,j,weights_laplacians_h)
'''
weight_function = MetaLaplacianFunction(weights_laplacians,
self.laplacian_functions)
weight_function_h = MetaLaplacianFunction(weights_laplacians_h,
self.laplacian_functions)
## load images and ground truth
file_seg = self.dir_reg + test + 'seg.hdr'
file_im = self.dir_reg + test + 'gray.hdr'
im = io_analyze.load(file_im)
seg = io_analyze.load(file_seg)
seg.flat[~np.in1d(seg.ravel(), self.labelset)] = self.labelset[0]
nim = im / np.std(im) # normalize image by std
## test training data ?
inference_train = True
if inference_train:
train_ims, train_segs, train_metas = self.training_set
for tim, tz, tmeta in zip(train_ims, train_segs, train_metas):
## retrieve metadata
islices = tmeta.pop('islices', None)
imask = tmeta.pop('imask', None)
iimask = tmeta.pop('iimask', None)
if islices is not None:
tseeds = self.seeds[islices]
tprior = {
'data': np.asarray(self.prior['data'])[:, iimask],
'imask': imask,
'variance': np.asarray(self.prior['variance'])[:,
iimask],
'labelset': self.labelset,
}
if 'intensity' in self.prior:
tprior['intensity'] = self.prior['intensity']
else:
tseeds = self.seeds
tprior = self.prior
## prior
tseg = self.labelset[np.argmax(tz, axis=0)].reshape(tim.shape)
tanchor_api = MetaAnchor(
tprior,
self.prior_functions,
weights_priors,
image=tim,
)
tsol, ty = rwsegment.segment(tim,
tanchor_api,
seeds=tseeds,
weight_function=weight_function,
**self.rwparams_inf)
## compute Dice coefficient
tdice = compute_dice_coef(tsol, tseg, labelset=self.labelset)
logger.info('Dice coefficients for train: \n{}'.format(tdice))
nlabel = len(self.labelset)
tflatmask = np.zeros(ty.shape, dtype=bool)
tflatmask[:, imask] = True
loss0 = loss_functions.ideal_loss(tz, ty, mask=tflatmask)
logger.info('Tloss = {}'.format(loss0))
## loss2: squared difference with ztilde
loss1 = loss_functions.anchor_loss(tz, ty, mask=tflatmask)
logger.info('SDloss = {}'.format(loss1))
## loss3: laplacian loss
loss2 = loss_functions.laplacian_loss(tz, ty, mask=tflatmask)
logger.info('LAPloss = {}'.format(loss2))
tanchor_api_h = MetaAnchor(
tprior,
self.prior_functions,
weights_priors_h,
image=tim,
)
tsol, ty = rwsegment.segment(tim,
tanchor_api_h,
seeds=tseeds,
weight_function=weight_function_h,
**self.rwparams_inf)
## compute Dice coefficient
tdice = compute_dice_coef(tsol, tseg, labelset=self.labelset)
logger.info(
'Dice coefficients for train (hand-tuned): \n{}'.format(
tdice))
loss0 = loss_functions.ideal_loss(tz, ty, mask=tflatmask)
logger.info('Tloss (hand-tuned) = {}'.format(loss0))
## loss2: squared difference with ztilde
loss1 = loss_functions.anchor_loss(tz, ty, mask=tflatmask)
logger.info('SDloss (hand-tuned) = {}'.format(loss1))
## loss3: laplacian loss
loss2 = loss_functions.laplacian_loss(tz, ty, mask=tflatmask)
logger.info('LAPloss (hand-tuned) = {}'.format(loss2))
break
## prior
anchor_api = MetaAnchor(
self.prior,
self.prior_functions,
weights_priors,
image=nim,
)
sol, y = rwsegment.segment(nim,
anchor_api,
seeds=self.seeds,
weight_function=weight_function,
**self.rwparams_inf)
## compute Dice coefficient
dice = compute_dice_coef(sol, seg, labelset=self.labelset)
logger.info('Dice coefficients: \n{}'.format(dice))
## objective
en_rw = rwsegment.energy_rw(nim,
y,
seeds=self.seeds,
weight_function=weight_function,
**self.rwparams_inf)
en_anchor = rwsegment.energy_anchor(nim,
y,
anchor_api,
seeds=self.seeds,
**self.rwparams_inf)
obj = en_rw + en_anchor
logger.info('Objective = {:.3}'.format(obj))
## compute losses
z = seg.ravel() == np.c_[self.labelset]
mask = self.seeds < 0
flatmask = mask.ravel() * np.ones((len(self.labelset), 1))
## loss 0 : 1 - Dice(y,z)
loss0 = loss_functions.ideal_loss(z, y, mask=flatmask)
logger.info('Tloss = {}'.format(loss0))
## loss2: squared difference with ztilde
loss1 = loss_functions.anchor_loss(z, y, mask=flatmask)
logger.info('SDloss = {}'.format(loss1))
## loss3: laplacian loss
loss2 = loss_functions.laplacian_loss(z, y, mask=flatmask)
logger.info('LAPloss = {}'.format(loss2))
## loss4: linear loss
loss3 = loss_functions.linear_loss(z, y, mask=flatmask)
logger.info('LINloss = {}'.format(loss3))
## saving
if self.debug:
pass
elif self.isroot:
outdir = self.dir_inf + test_dir
logger.info('saving data in: {}'.format(outdir))
if not os.path.isdir(outdir):
os.makedirs(outdir)
#io_analyze.save(outdir + 'im.hdr',im.astype(np.int32))
#np.save(outdir + 'y.npy',y)
#io_analyze.save(outdir + 'sol.hdr',sol.astype(np.int32))
np.savetxt(outdir + 'objective.txt', [obj])
np.savetxt(outdir + 'dice.txt',
np.c_[dice.keys(), dice.values()],
fmt='%d %f')
f = open(outdir + 'losses.txt', 'w')
f.write('ideal_loss\t{}\n'.format(loss0))
f.write('anchor_loss\t{}\n'.format(loss1))
f.write('laplacian_loss\t{}\n'.format(loss2))
f.close()
def process_sample(self,test,fold=None):
## get prior
prior, mask = load_or_compute_prior_and_mask(
test,
fold=fold,
force_recompute=self.force_recompute_prior)
seeds = (-1)*mask
## load image
file_name = config.dir_reg + test + 'gray.hdr'
logger.info('segmenting data: {}'.format(file_name))
im = io_analyze.load(file_name)
file_gt = config.dir_reg + test + 'seg.hdr'
seg = io_analyze.load(file_gt)
seg.flat[~np.in1d(seg, self.labelset)] = self.labelset[0]
## normalize image
nim = im/np.std(im)
## init anchor_api
anchor_api = MetaAnchor(
prior=prior,
prior_models=self.prior_models,
prior_weights=self.prior_weights,
image=nim,
)
## start segmenting
#import ipdb; ipdb.set_trace()
sol,y = rwsegment.segment(
nim,
anchor_api,
seeds=seeds,
labelset=self.labelset,
weight_function=self.weight_function,
**self.params
)
## compute losses
z = seg.ravel()==np.c_[self.labelset]
flatmask = mask.ravel()*np.ones((len(self.labelset),1))
## loss 0 : 1 - Dice(y,z)
loss0 = loss_functions.ideal_loss(z,y,mask=flatmask)
logger.info('Tloss = {}'.format(loss0))
## loss2: squared difference with ztilde
loss1 = loss_functions.anchor_loss(z,y,mask=flatmask)
logger.info('SDloss = {}'.format(loss1))
## loss3: laplacian loss
loss2 = loss_functions.laplacian_loss(z,y,mask=flatmask)
logger.info('LAPloss = {}'.format(loss2))
## loss4: linear loss
loss3 = loss_functions.linear_loss(z,y,mask=flatmask)
logger.info('LINloss = {}'.format(loss3))
## compute Dice coefficient per label
dice = compute_dice_coef(sol, seg,labelset=self.labelset)
logger.info('Dice: {}'.format(dice))
if not config.debug:
if fold is not None:
test_name = 'f{}_{}'.format(fold[0][:2], test)
else:
test_name = test
outdir = config.dir_seg + \
'/{}/{}'.format(self.model_name,test_name)
logger.info('saving data in: {}'.format(outdir))
if not os.path.isdir(outdir):
os.makedirs(outdir)
f = open(outdir + 'losses.txt', 'w')
f.write('ideal_loss\t{}\n'.format(loss0))
f.write('anchor_loss\t{}\n'.format(loss1))
f.write('laplacian_loss\t{}\n'.format(loss2))
f.close()
io_analyze.save(outdir + 'sol.hdr', sol.astype(np.int32))
np.savetxt(
outdir + 'dice.txt', np.c_[dice.keys(),dice.values()],fmt='%d %.8f')
def compute_mean_segmentation(self, list):
for test in list:
file_gt = config.dir_reg + test + 'seg.hdr'
seg = io_analyze.load(file_gt)
seg.flat[~np.in1d(seg, self.labelset)] = self.labelset[0]
## get prior
prior, mask = load_or_compute_prior_and_mask(
test,force_recompute=self.force_recompute_prior)
mask = mask.astype(bool)
y = np.zeros((len(self.labelset),seg.size))
y[:,0] = 1
y.flat[prior['imask']] = prior['data']
sol = np.zeros(seg.shape,dtype=np.int32)
sol[mask] = self.labelset[np.argmax(prior['data'],axis=0)]
## compute losses
z = seg.ravel()==np.c_[self.labelset]
flatmask = mask.ravel()*np.ones((len(self.labelset),1))
## loss 0 : 1 - Dice(y,z)
loss0 = loss_functions.ideal_loss(z,y,mask=flatmask)
logger.info('Tloss = {}'.format(loss0))
## loss2: squared difference with ztilde
#loss1 = loss_functions.anchor_loss(z,y,mask=flatmask)
#logger.info('SDloss = {}'.format(loss1))
## loss3: laplacian loss
#loss2 = loss_functions.laplacian_loss(z,y,mask=flatmask)
#logger.info('LAPloss = {}'.format(loss2))
## loss4: linear loss
#loss3 = loss_functions.linear_loss(z,y,mask=flatmask)
#logger.info('LINloss = {}'.format(loss3))
## compute Dice coefficient per label
dice = compute_dice_coef(sol, seg,labelset=self.labelset)
logger.info('Dice: {}'.format(dice))
if not config.debug:
outdir = config.dir_seg + \
'/{}/{}'.format('mean',test)
logger.info('saving data in: {}'.format(outdir))
if not os.path.isdir(outdir):
os.makedirs(outdir)
#f = open(outdir + 'losses.txt', 'w')
#f.write('ideal_loss\t{}\n'.format(loss0))
#f.write('anchor_loss\t{}\n'.format(loss1))
#f.write('laplacian_loss\t{}\n'.format(loss2))
#f.close()
io_analyze.save(outdir + 'sol.hdr', sol.astype(np.int32))
np.savetxt(
outdir + 'dice.txt', np.c_[dice.keys(),dice.values()],fmt='%d %.8f')
def compute_approximate_aci(self, w, x, z, y0, **kwargs):
logger.info("using approximate aci (Danny's)")
islices = kwargs.pop('islices', None)
imask = kwargs.pop('imask', None)
iimask = kwargs.pop('iimask', None)
if islices is not None:
seeds = self.seeds[islices]
mask = [
self.immask[islices].ravel() for i in range(len(self.labelset))
]
prior = {
'data': np.asarray(self.prior['data'])[:, iimask],
'imask': imask,
'variance': np.asarray(self.prior['variance'])[:, iimask],
'labelset': self.labelset,
}
if 'intensity' in self.prior:
prior['intensity'] = self.prior['intensity']
else:
mask = self.mask
seeds = self.seeds
prior = self.prior
weight_function = MetaLaplacianFunction(
np.asarray(w)[self.indices_laplacians],
self.laplacian_functions,
)
## combine all prior models
anchor_api = MetaAnchor(
prior=prior,
prior_models=self.prior_models,
prior_weights=np.asarray(w)[self.indices_priors],
image=x,
)
class GroundTruthAnchor(object):
def __init__(self, anchor_api, gt, gt_weights):
self.anchor_api = anchor_api
self.gt = gt
self.gt_weights = gt_weights
def get_labelset(self):
return self.anchor_api.get_labelset()
def get_anchor_and_weights(self, D, indices):
anchor, weights = self.anchor_api.get_anchor_and_weights(
D, indices)
gt_weights = self.gt_weights[:, indices]
gt = self.gt[:, indices]
new_weights = weights + gt_weights
new_anchor = (anchor * weights + gt * gt_weights) / new_weights
return new_anchor, new_weights
self.approx_aci_maxiter = 200
self.approx_aci_maxstep = 1e-2
z_weights = np.zeros(np.asarray(z).shape)
z_label = np.argmax(z, axis=0)
for i in range(self.approx_aci_maxiter):
logger.debug("approx aci, iter={}".format(i))
## add ground truth to anchor api
modified_api = GroundTruthAnchor(anchor_api, z, z_weights)
## inference
y_ = rwsegment.segment(x,
modified_api,
seeds=seeds,
weight_function=weight_function,
return_arguments=['y'],
**self.rwparams)
## loss
#loss = self.compute_loss(z,y_, islices=islices)
loss = loss_functions.ideal_loss(z, y_, mask=mask)
logger.debug('loss = {}'.format(loss))
if loss < 1e-8:
break
## uptade weights
delta = np.max(y_ - y_[z_label, np.arange(y_.shape[1])], axis=0)
delta = np.clip(delta, 0, self.approx_aci_maxstep)
z_weights += delta
return y_
