def get_predictions_BATCH(self, itype_list, image_id_list, imgs_list, batch_size = None, verbose=False):
'''
Predict from a list of imgs (outputs from self.read_image)
'''
for itype, image_id, imgs in zip(itype_list, image_id_list, imgs_list):
#get weights
if (self.weights_file is None):
self.dsetID = ld.read_dsetID() if self.dsetID is None else self.dsetID
fold_id = self.dsetID.loc[(self.dsetID.video_id == image_id) & (self.dsetID.itype == itype),
self.fold_column]
fold_id = fold_id.values[0]
if self.prev_foldID != fold_id:
weight_file = self.weights_format.format(fold_id=fold_id)
self.load_weights(weight_file, verbose=False)
self.prev_foldID = fold_id
# predict
pred = self.predict_BATCH(imgs, batch_size = batch_size)
# Save cache
if not os.path.exists(os.path.join(self.path_predictions, itype)):
os.makedirs(os.path.join(self.path_predictions, itype))
file_to_save = os.path.join(self.path_predictions, itype, '{}_{}_pred.npy'.format(itype, image_id))
np.save(file_to_save, pred)
with open(file_to_save, 'rb') as f_in, gzip.open(file_to_save + '.gz', 'wb') as f_out:
shutil.copyfileobj(f_in, f_out)
os.remove(file_to_save)
start_time = eval(exe.initiate_task_rA1.func_code)
# READ MODEL
Model = eval(exe.read_model_rA1.func_code)
# READ PYTORCH NNMODEL & PRINT INFO
import torch
eval(exe.read_pytorch_NNmodel_rA1.func_code)
##### COMMON SETTINGS #####
# READ & PREPARE DATASET
print('-' * 40)
print('READING DATASET')
Data = ld.FishDATA()
dsetID = ld.read_dsetID()
imgs_df = dsetID[((dsetID.itype == 'train') & (~dsetID.exclude))]
#imgs_df = pd.merge(imgs_df, Data.annotations, how='inner', on='video_id')
imgs_df = imgs_df.reset_index(
drop=True) # Important to keep consistancy between list index
imgs_df = imgs_df.assign(idf=imgs_df.index)
imgs_df.rename(columns={'video_id': 'image_id'}, inplace=True)
if debug_mode:
print(' DEBUG MODE ACTIVATED!!!!')
imgs_df = imgs_df[0:100]
# READ IMAGES IN MEMORY
print('LOADING IMAGES INTO RAM')
def parallel_function(i_row):
return Model.read_image(i_row.itype,
def get_predictions(self,
itype,
image_id,
return_imgs=False,
avoid_read_weights=False,
return_score=False,
use_cache=None,
force_save=False,
verbose=True):
start_time_L1 = time.time()
use_cache = self.Data.exec_settings[
'cache'] == "True" if use_cache is None else use_cache
pred = None
score = None
score_txt = 'R2_score'
if use_cache & (not force_save):
try:
file_to_load = os.path.join(
self.path_predictions, itype,
'{}_{}_pred.npy.gz'.format(itype, image_id))
with gzip.open(file_to_load, 'rb') as f:
pred = np.load(f)
if not return_imgs:
if verbose:
print("Read prediction {}_{} in {:.2f} s".format(
itype, image_id,
(time.time() - start_time_L1) / 1))
return pred
except:
if verbose:
print("File not in cache")
imgs, labels, info = self.read_image(itype,
image_id,
frame='all',
split_wrap_imgs=True,
read_labels=(itype == 'train'),
verbose=verbose)
if pred is None:
#get weights
if (self.weights_file is None) or not avoid_read_weights:
self.dsetID = ld.read_dsetID(
) if self.dsetID is None else self.dsetID
fold_id = self.dsetID.loc[(self.dsetID.video_id == image_id) &
(self.dsetID.itype == itype),
self.fold_column]
fold_id = fold_id.values[0]
if self.prev_foldID != fold_id:
weight_file = self.weights_format.format(fold_id=fold_id)
self.load_weights(weight_file, verbose=verbose)
self.prev_foldID = fold_id
# predict
pred = self.predict_BATCH(imgs)
# Save cache
if use_cache | force_save:
if not os.path.exists(
os.path.join(self.path_predictions, itype)):
os.makedirs(os.path.join(self.path_predictions, itype))
file_to_save = os.path.join(
self.path_predictions, itype,
'{}_{}_pred.npy'.format(itype, image_id))
np.save(file_to_save, pred)
with open(file_to_save,
'rb') as f_in, gzip.open(file_to_save + '.gz',
'wb') as f_out:
shutil.copyfileobj(f_in, f_out)
os.remove(file_to_save)
# evaluate
if labels is not None:
from sklearn.metrics import r2_score
np_labels = np.vstack(labels)[:, 0]
np_preds = pred[:, 0]
y_true = (np_labels[np.logical_not(np.isnan(np_labels))]).astype(
np.float32)
y_pred = (np_preds[np.logical_not(np.isnan(np_labels))]).astype(
np.float32)
score = r2_score(y_true, y_pred)
if verbose:
if score is not None:
print("Read prediction {}_{} ({}: {:.5f}) in {:.2f} s".format(
itype, image_id, score_txt, score,
(time.time() - start_time_L1) / 1))
else:
print("Read prediction {}_{} in {:.2f} s".format(
itype, image_id, (time.time() - start_time_L1) / 1))
if return_imgs:
if return_score:
return pred, imgs, labels, score
else:
return pred, imgs, labels
if return_score:
return pred, score
else:
return pred
def get_predictions(self,
itype,
image_id,
return_img=False,
avoid_read_weights=False,
return_score=False,
thr=0.8,
use_cache=None,
force_save=False,
verbose=True):
start_time_L1 = time.time()
use_cache = self.Data.exec_settings[
'cache'] == "True" if use_cache is None else use_cache
score = None
pred = None
if use_cache & (not force_save):
try:
file_to_load = os.path.join(
self.path_predictions, itype,
'{}_{}_pred.npy.gz'.format(itype, image_id))
with gzip.open(file_to_load, 'rb') as f:
pred = np.load(f)
if not return_img:
if verbose:
print("Read prediction {}_{} in {:.2f} s".format(
itype, image_id,
(time.time() - start_time_L1) / 1))
return pred, None, None
except:
if verbose:
print("File not in cache")
imgs, msk, info = self.read_image_PRED(itype,
image_id,
read_mask=(itype == 'train'),
verbose=verbose)
if pred is None:
#get weights
if (self.weights_file is None) or not avoid_read_weights:
self.dsetID = ld.read_dsetID(
) if self.dsetID is None else self.dsetID
fold_id = self.dsetID.loc[(self.dsetID.video_id == image_id) &
(self.dsetID.itype == itype),
self.fold_column]
fold_id = fold_id.values[0]
if self.prev_foldID != fold_id:
weight_file = self.weights_format.format(fold_id=fold_id)
self.load_weights(weight_file, verbose=verbose)
self.prev_foldID = fold_id
# predict
preds = self.predict_BATCH(imgs)
pred = np.max(np.array(preds), axis=0) ##### MAX!!!
# Save cache
if use_cache | force_save:
if not os.path.exists(
os.path.join(self.path_predictions, itype)):
os.makedirs(os.path.join(self.path_predictions, itype))
file_to_save = os.path.join(
self.path_predictions, itype,
'{}_{}_pred.npy'.format(itype, image_id))
np.save(file_to_save, pred)
with open(file_to_save,
'rb') as f_in, gzip.open(file_to_save + '.gz',
'wb') as f_out:
shutil.copyfileobj(f_in, f_out)
os.remove(file_to_save)
# evaluate
if msk is not None:
score = ld.dice_coef(pred[0], msk[0], thr=thr)
if verbose:
if score is not None:
print(
"Read prediction {}_{} (score: {:.5f}) in {:.2f} s".format(
itype, image_id, score,
(time.time() - start_time_L1) / 1))
else:
print("Read prediction {}_{} in {:.2f} s".format(
itype, image_id, (time.time() - start_time_L1) / 1))
if return_img:
if return_score:
return pred, imgs[0], msk, score
else:
return pred, imgs[0], msk
if return_score:
return pred, score
else:
return pred
def get_predictions(self,
itype,
image_id,
return_imgs=False,
avoid_read_weights=False,
return_score=False,
use_cache=None,
force_save=False,
verbose=True):
start_time_L1 = time.time()
use_cache = self.Data.exec_settings[
'cache'] == "True" if use_cache is None else use_cache
labels = None
score = None
pred = None
score_txt = 'dice_coef'
if use_cache & (not force_save):
try:
file_to_load = os.path.join(
self.path_predictions, itype,
'{}_{}_pred.csv.gz'.format(itype, image_id))
labels = pd.read_csv(file_to_load)
if not return_imgs:
if verbose:
print("Read prediction {}_{} in {:.2f} s".format(
itype, image_id,
(time.time() - start_time_L1) / 1))
return labels
except:
if verbose:
print("File not in cache")
imgs, msks, info = self.read_image(itype,
image_id,
frame='all',
split_wrap_imgs=True,
read_labels=(itype == 'train'),
verbose=verbose)
if labels is None:
#get weights
if (self.weights_file is None) or not avoid_read_weights:
self.dsetID = ld.read_dsetID(
) if self.dsetID is None else self.dsetID
fold_id = self.dsetID.loc[(self.dsetID.video_id == image_id) &
(self.dsetID.itype == itype),
self.fold_column]
fold_id = fold_id.values[0]
if self.prev_foldID != fold_id:
weight_file = self.weights_format.format(fold_id=fold_id)
self.load_weights(weight_file, verbose=verbose)
self.prev_foldID = fold_id
# predict
pred = self.predict_BATCH(imgs)
#scale predictions
sPred = pred[:, 0, ...].astype(np.float32)
sPred = lt.scale_image(sPred,
new_size=self.pp_patch_size,
method='linear')
# get regions
import skimage.morphology as morph
from skimage.measure import regionprops
pred_thr = np.where(sPred >= self.thr, 1.0, 0.0)
pred_labels = np.array([
morph.label(pred_thr[s]) for s in range(pred_thr.shape[0])
]).astype(int)
regions_lst = [
regionprops(pred_labels[s])
for s in range(pred_labels.shape[0])
]
# create list
labels = []
for ich, regions in enumerate(regions_lst):
if len(regions) == 0:
center = (np.nan, np.nan)
ang = np.nan
length = np.nan
else:
region = regions[np.argmax([
region.area for region in regions
])] # take biggest region
center = np.round(region.centroid).astype(int)
ang = np.round(
region.orientation * 180 / math.pi).astype(int) + 90
length = int(math.ceil(region.major_axis_length))
labels.append(
[image_id, ich, center[0], center[1], ang, length])
labels = pd.DataFrame(
labels,
columns=['image_id', 'ich', 'xc', 'yc', 'ang', 'length'])
# Save cache
if use_cache | force_save:
if not os.path.exists(
os.path.join(self.path_predictions, itype)):
os.makedirs(os.path.join(self.path_predictions, itype))
file_to_save = os.path.join(
self.path_predictions, itype,
'{}_{}_pred.csv.gz'.format(itype, image_id))
labels.to_csv(file_to_save, index=False, compression='gzip')
# evaluate
if (msks is not None) and (pred is not None):
pp_labels = [
self.data_transforms['test'](s1, s1)[1] for s1 in msks
]
select = [np.sum(s1) > 0 for s1 in pp_labels]
np_labels = [s1 for s1, s2 in zip(pp_labels, select) if s2]
np_labels = np.vstack(np_labels)
np_preds = [s1 for s1, s2 in zip(pred, select) if s2]
np_preds = np.vstack(np_preds)
score = ld.dice_coef(np_preds, np_labels, thr=self.thr)
if verbose:
if score is not None:
print("Read prediction {}_{} ({}: {:.5f}) in {:.2f} s".format(
itype, image_id, score_txt, score,
(time.time() - start_time_L1) / 1))
else:
print("Read prediction {}_{} in {:.2f} s".format(
itype, image_id, (time.time() - start_time_L1) / 1))
if return_imgs:
if return_score:
return labels, imgs, msks, score
else:
return labels, imgs, msks
if return_score:
return labels, score
else:
return labels
def get_predictions_raw(self,
itype,
image_id,
return_imgs=False,
avoid_read_weights=False,
return_score=False,
thr=0.8,
use_cache=None,
force_save=False,
verbose=True):
start_time_L1 = time.time()
use_cache = self.Data.exec_settings[
'cache'] == "True" if use_cache is None else use_cache
pred = None
score = None
score_txt = 'dice_coef'
if use_cache & (not force_save):
try:
file_to_load = os.path.join(
self.path_predictions, itype,
'{}_{}_pred.npy.gz'.format(itype, image_id))
with gzip.open(file_to_load, 'rb') as f:
pred = np.load(f)
if not return_imgs:
if verbose:
print("Read prediction {}_{} in {:.2f} s".format(
itype, image_id,
(time.time() - start_time_L1) / 1))
return pred
except:
if verbose:
print("File not in cache")
imgs, labels, info = self.read_image(itype,
image_id,
frame='all',
split_wrap_imgs=True,
read_labels=(itype == 'train'),
verbose=verbose)
if pred is None:
#get weights
if (self.weights_file is None) or not avoid_read_weights:
self.dsetID = ld.read_dsetID(
) if self.dsetID is None else self.dsetID
fold_id = self.dsetID.loc[(self.dsetID.video_id == image_id) &
(self.dsetID.itype == itype),
self.fold_column]
fold_id = fold_id.values[0]
if self.prev_foldID != fold_id:
weight_file = self.weights_format.format(fold_id=fold_id)
self.load_weights(weight_file, verbose=verbose)
self.prev_foldID = fold_id
# predict
pred = self.predict_BATCH(imgs)
# Save cache
if use_cache | force_save:
if not os.path.exists(
os.path.join(self.path_predictions, itype)):
os.makedirs(os.path.join(self.path_predictions, itype))
file_to_save = os.path.join(
self.path_predictions, itype,
'{}_{}_pred.npy'.format(itype, image_id))
np.save(file_to_save, pred)
with open(file_to_save,
'rb') as f_in, gzip.open(file_to_save + '.gz',
'wb') as f_out:
shutil.copyfileobj(f_in, f_out)
os.remove(file_to_save)
# evaluate
if labels is not None:
pp_labels = [
self.data_transforms['test'](s1, s1)[1] for s1 in labels
]
select = [np.sum(s1) > 0 for s1 in pp_labels]
np_labels = [s1 for s1, s2 in zip(pp_labels, select) if s2]
np_labels = np.vstack(np_labels)
np_preds = [s1 for s1, s2 in zip(pred, select) if s2]
np_preds = np.vstack(np_preds)
score = ld.dice_coef(np_preds, np_labels, thr=thr)
if verbose:
if score is not None:
print("Read prediction {}_{} ({}: {:.5f}) in {:.2f} s".format(
itype, image_id, score_txt, score,
(time.time() - start_time_L1) / 1))
else:
print("Read prediction {}_{} in {:.2f} s".format(
itype, image_id, (time.time() - start_time_L1) / 1))
if return_imgs:
if return_score:
return pred, imgs, labels, score
else:
return pred, imgs, labels
if return_score:
return pred, score
else:
return pred
def get_predictions(self,
itype,
image_id,
return_dset=False,
avoid_read_model=False,
return_score=False,
use_cache=None,
force_save=False,
verbose=True):
start_time_L1 = time.time()
use_cache = self.Data.exec_settings[
'cache'] == "True" if use_cache is None else use_cache
pred = None
score = None
score_txt = 'mse'
if use_cache & (not force_save):
try:
file_to_load = os.path.join(
self.path_predictions, itype,
'{}_{}_pred.npy.gz'.format(itype, image_id))
with gzip.open(file_to_load, 'rb') as f:
pred = np.load(f)
if not return_dset:
if verbose:
print("Read prediction {}_{} in {:.2f} s".format(
itype, image_id,
(time.time() - start_time_L1) / 1))
return pred
except:
if verbose:
print("File not in cache")
dset = self.read_image(itype,
image_id,
frame='all',
read_targets=(itype == 'train'),
verbose=verbose)
if pred is None:
#get model
if (self.model_file is None) or not avoid_read_model:
self.dsetID = ld.read_dsetID(
) if self.dsetID is None else self.dsetID
fold_id = self.dsetID.loc[(self.dsetID.video_id == image_id) &
(self.dsetID.itype == itype),
self.fold_column]
fold_id = fold_id.values[0]
if self.prev_foldID != fold_id:
model_filename = self.model_filename_format.format(
fold_id=fold_id)
self.load_model(model_filename, verbose=verbose)
self.prev_foldID = fold_id
# predict
pred = self.predict(dset)
# Save cache
if use_cache | force_save:
if not os.path.exists(
os.path.join(self.path_predictions, itype)):
os.makedirs(os.path.join(self.path_predictions, itype))
file_to_save = os.path.join(
self.path_predictions, itype,
'{}_{}_pred.npy'.format(itype, image_id))
np.save(file_to_save, pred)
with open(file_to_save,
'rb') as f_in, gzip.open(file_to_save + '.gz',
'wb') as f_out:
shutil.copyfileobj(f_in, f_out)
os.remove(file_to_save)
# evaluate
labels = None
if (itype == 'train'):
labels = labels = dset['target'].values.astype(np.float32)
from sklearn.metrics import log_loss
y_true = labels[~np.isnan(labels)]
y_pred = pred[~np.isnan(labels)]
score = log_loss(y_true, y_pred)
if verbose:
if score is not None:
print("Read prediction {}_{} ({}: {:.5f}) in {:.2f} s".format(
itype, image_id, score_txt, score,
(time.time() - start_time_L1) / 1))
else:
print("Read prediction {}_{} in {:.2f} s".format(
itype, image_id, (time.time() - start_time_L1) / 1))
if return_dset:
if return_score:
return pred, dset, labels, score
else:
return pred, dset, labels
if return_score:
return pred, score
else:
return pred
