def compute_psi(self, x,y, **kwargs):
''' - sum(a){Ea(x,y)} '''
islices = kwargs.pop('islices',None)
imask = kwargs.pop('imask',None)
iimask = kwargs.pop('iimask',None)
if islices is not None:
im = x
seeds = self.seeds[islices]
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']
seg = y
else:
im = x
seeds = self.seeds
prior = self.prior
seg = y
## normalizing by the approximate mask size
# normalize = float(nnode)/100.0
normalize = 1.0
## energy value for each weighting function
v = []
for wf in self.laplacian_functions:
v.append(
rwsegment.energy_rw(
im, seg,
seeds=seeds,
weight_function=wf,
**self.rwparams
)/normalize)
## energy for each prior models
for model in self.prior_models:
anchor_api = model(
prior,
anchor_weight=1.0,
image=im, # intensity prior needs an image
)
v.append(
rwsegment.energy_anchor(
im, seg, anchor_api,
seeds=seeds,
weight_function=wf,
**self.rwparams
)/normalize)
return v
def compute_psi(self, x, y, **kwargs):
''' - sum(a){Ea(x,y)} '''
islices = kwargs.pop('islices', None)
imask = kwargs.pop('imask', None)
iimask = kwargs.pop('iimask', None)
if islices is not None:
im = x
seeds = self.seeds[islices]
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']
seg = y
else:
im = x
seeds = self.seeds
prior = self.prior
seg = y
## normalizing by the approximate mask size
# normalize = float(nnode)/100.0
normalize = 1.0
## energy value for each weighting function
v = []
for wf in self.laplacian_functions:
v.append(
rwsegment.energy_rw(
im, seg, seeds=seeds, weight_function=wf, **self.rwparams)
/ normalize)
## energy for each prior models
for model in self.prior_models:
anchor_api = model(
prior,
anchor_weight=1.0,
image=im, # intensity prior needs an image
)
v.append(
rwsegment.energy_anchor(im,
seg,
anchor_api,
seeds=seeds,
weight_function=wf,
**self.rwparams) / normalize)
return v
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_features(test, train, y):
im = io_analyze.load(config.dir_reg + test + train + 'reggray.hdr')
nim = im/np.std(im)
prior,mask = load_or_compute_prior_and_mask(
test, force_recompute=False)
seeds = (-1)*mask.astype(int)
from rwsegment import rwsegment_prior_models as models
from rwsegment import weight_functions as wflib
rwparams = {
'labelset': np.asarray(config.labelset),
}
weight_functions = {
'std_b10' : lambda im: wflib.weight_std(im, beta=10),
'std_b50' : lambda im: wflib.weight_std(im, beta=50),
'std_b100' : lambda im: wflib.weight_std(im, beta=100),
'inv_b100o1' : lambda im: wflib.weight_inv(im, beta=100, offset=1),
# 'pdiff_r1b10': lambda im: wflib.weight_patch_diff(im, r0=1, beta=10),
# 'pdiff_r2b10': lambda im: wflib.weight_patch_diff(im, r0=2, beta=10),
# 'pdiff_r1b50' : lambda im: wflib.weight_patch_diff(im, r0=1, beta=50),
}
prior_models = {
'constant': models.Constant,
'entropy': models.Entropy_no_D,
'intensity': models.Intensity,
}
## indices of w
nlaplacian = len(weight_functions)
nprior = len(prior_models)
indices_laplacians = np.arange(nlaplacian)
indices_priors = np.arange(nlaplacian,nlaplacian + nprior)
laplacian_functions = weight_functions.values()
laplacian_names = weight_functions.keys()
prior_functions = prior_models.values()
prior_names = prior_models.keys()
#from svm_rw_api import MetaAnchor
#anchor_api = MetaAnchor(
# prior,
# prior_functions,
# weights_priors,
# image=im,
# )
from rwsegment import rwsegment
for fname in weight_functions:
wf = weight_functions[fname]
en_rw = rwsegment.energy_rw(
nim,
y,
seeds=seeds,
weight_function=wf,
**rwparams
)
print fname, en_rw
for mname in prior_models:
pm = prior_models[mname](prior,1., image=nim)
en_anchor = rwsegment.energy_anchor(
nim,
y,
pm,
seeds=seeds,
**rwparams
)
print mname, en_anchor
def compute_objective(test, y, w):
im = io_analyze.load(config.dir_reg + test + 'gray.hdr')
nim = im/np.std(im)
prior,mask = load_or_compute_prior_and_mask(
test, force_recompute=False)
seeds = (-1)*mask.astype(int)
from rwsegment import rwsegment_prior_models as models
from rwsegment import weight_functions as wflib
rwparams = {
'labelset': np.asarray(config.labelset),
# optimization
'rtol': 1e-6,
'maxiter': 1e3,
'per_label':True,
'optim_solver':'unconstrained',
}
weight_functions = {
'std_b10' : lambda im: wflib.weight_std(im, beta=10),
'std_b50' : lambda im: wflib.weight_std(im, beta=50),
'std_b100' : lambda im: wflib.weight_std(im, beta=100),
'inv_b100o1' : lambda im: wflib.weight_inv(im, beta=100, offset=1),
# 'pdiff_r1b10': lambda im: wflib.weight_patch_diff(im, r0=1, beta=10),
# 'pdiff_r2b10': lambda im: wflib.weight_patch_diff(im, r0=2, beta=10),
# 'pdiff_r1b50' : lambda im: wflib.weight_patch_diff(im, r0=1, beta=50),
}
prior_models = {
'constant': models.Constant,
'entropy': models.Entropy_no_D,
'intensity': models.Intensity,
}
## indices of w
nlaplacian = len(weight_functions)
nprior = len(prior_models)
indices_laplacians = np.arange(nlaplacian)
indices_priors = np.arange(nlaplacian,nlaplacian + nprior)
laplacian_functions = weight_functions.values()
laplacian_names = weight_functions.keys()
prior_functions = prior_models.values()
prior_names = prior_models.keys()
weights_laplacians = np.asarray(w)[indices_laplacians]
weights_priors = np.asarray(w)[indices_priors]
def meta_weight_functions(im,_w):
''' meta weight function'''
data = 0
for iwf,wf in enumerate(laplacian_functions):
ij,_data = wf(im)
data += _w[iwf]*_data
return ij, data
weight_function = lambda im: meta_weight_functions(im, weights_laplacians)
from svm_rw_api import MetaAnchor
anchor_api = MetaAnchor(
prior,
prior_functions,
weights_priors,
image=nim,
)
from rwsegment import rwsegment
en_rw = rwsegment.energy_rw(
nim,
y,
seeds=seeds,
weight_function=weight_function,
**rwparams
)
en_anchor = rwsegment.energy_anchor(
nim,
y,
anchor_api,
seeds=seeds,
**rwparams
)
obj = en_rw + en_anchor
return obj
def compute_features(test, train, y):
im = io_analyze.load(config.dir_reg + test + train + 'reggray.hdr')
nim = im / np.std(im)
prior, mask = load_or_compute_prior_and_mask(test, force_recompute=False)
seeds = (-1) * mask.astype(int)
from rwsegment import rwsegment_prior_models as models
from rwsegment import weight_functions as wflib
rwparams = {
'labelset': np.asarray(config.labelset),
}
weight_functions = {
'std_b10': lambda im: wflib.weight_std(im, beta=10),
'std_b50': lambda im: wflib.weight_std(im, beta=50),
'std_b100': lambda im: wflib.weight_std(im, beta=100),
'inv_b100o1': lambda im: wflib.weight_inv(im, beta=100, offset=1),
# 'pdiff_r1b10': lambda im: wflib.weight_patch_diff(im, r0=1, beta=10),
# 'pdiff_r2b10': lambda im: wflib.weight_patch_diff(im, r0=2, beta=10),
# 'pdiff_r1b50' : lambda im: wflib.weight_patch_diff(im, r0=1, beta=50),
}
prior_models = {
'constant': models.Constant,
'entropy': models.Entropy_no_D,
'intensity': models.Intensity,
}
## indices of w
nlaplacian = len(weight_functions)
nprior = len(prior_models)
indices_laplacians = np.arange(nlaplacian)
indices_priors = np.arange(nlaplacian, nlaplacian + nprior)
laplacian_functions = weight_functions.values()
laplacian_names = weight_functions.keys()
prior_functions = prior_models.values()
prior_names = prior_models.keys()
#from svm_rw_api import MetaAnchor
#anchor_api = MetaAnchor(
# prior,
# prior_functions,
# weights_priors,
# image=im,
# )
from rwsegment import rwsegment
for fname in weight_functions:
wf = weight_functions[fname]
en_rw = rwsegment.energy_rw(nim,
y,
seeds=seeds,
weight_function=wf,
**rwparams)
print fname, en_rw
for mname in prior_models:
pm = prior_models[mname](prior, 1., image=nim)
en_anchor = rwsegment.energy_anchor(nim,
y,
pm,
seeds=seeds,
**rwparams)
print mname, en_anchor
def compute_objective(test, y, w):
im = io_analyze.load(config.dir_reg + test + 'gray.hdr')
nim = im / np.std(im)
prior, mask = load_or_compute_prior_and_mask(test, force_recompute=False)
seeds = (-1) * mask.astype(int)
from rwsegment import rwsegment_prior_models as models
from rwsegment import weight_functions as wflib
rwparams = {
'labelset': np.asarray(config.labelset),
# optimization
'rtol': 1e-6,
'maxiter': 1e3,
'per_label': True,
'optim_solver': 'unconstrained',
}
weight_functions = {
'std_b10': lambda im: wflib.weight_std(im, beta=10),
'std_b50': lambda im: wflib.weight_std(im, beta=50),
'std_b100': lambda im: wflib.weight_std(im, beta=100),
'inv_b100o1': lambda im: wflib.weight_inv(im, beta=100, offset=1),
# 'pdiff_r1b10': lambda im: wflib.weight_patch_diff(im, r0=1, beta=10),
# 'pdiff_r2b10': lambda im: wflib.weight_patch_diff(im, r0=2, beta=10),
# 'pdiff_r1b50' : lambda im: wflib.weight_patch_diff(im, r0=1, beta=50),
}
prior_models = {
'constant': models.Constant,
'entropy': models.Entropy_no_D,
'intensity': models.Intensity,
}
## indices of w
nlaplacian = len(weight_functions)
nprior = len(prior_models)
indices_laplacians = np.arange(nlaplacian)
indices_priors = np.arange(nlaplacian, nlaplacian + nprior)
laplacian_functions = weight_functions.values()
laplacian_names = weight_functions.keys()
prior_functions = prior_models.values()
prior_names = prior_models.keys()
weights_laplacians = np.asarray(w)[indices_laplacians]
weights_priors = np.asarray(w)[indices_priors]
def meta_weight_functions(im, _w):
''' meta weight function'''
data = 0
for iwf, wf in enumerate(laplacian_functions):
ij, _data = wf(im)
data += _w[iwf] * _data
return ij, data
weight_function = lambda im: meta_weight_functions(im, weights_laplacians)
from svm_rw_api import MetaAnchor
anchor_api = MetaAnchor(
prior,
prior_functions,
weights_priors,
image=nim,
)
from rwsegment import rwsegment
en_rw = rwsegment.energy_rw(nim,
y,
seeds=seeds,
weight_function=weight_function,
**rwparams)
en_anchor = rwsegment.energy_anchor(nim,
y,
anchor_api,
seeds=seeds,
**rwparams)
obj = en_rw + en_anchor
return obj
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()
