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