def visQuantitative(model, batch, win="", return_image=False): if 1: # Preds pred_dict_dice = model.predict(batch, predict_method="BestDice") pred_dict_blobs = model.predict(batch, predict_method="blobs") pred_dict_OB = au.pointList2BestObjectness(batch["lcfcn_pointList"], batch) # Counts count_diff(pred_dict_dice, batch) img_points = get_image_points(batch) blob_dict = au.annList2mask(pred_dict_blobs["annList"], color=1) dice_dict = au.annList2mask(pred_dict_dice["annList"], color=1) OB_dict = au.annList2mask(pred_dict_OB["annList"], color=1) img_blobs = ms.get_image(img_points, blob_dict["mask"]) img_dice = ms.get_image(img_points, dice_dict["mask"]) img_OB = ms.get_image(img_points, OB_dict["mask"]) img_points = rescale_image(img_points, "Original", n_preds=batch["counts"].sum().item()) if img_points.shape[-1] > img_points.shape[-2]: axis = 1 else: axis = 0 imgAll = np.concatenate([img_points, rescale_image(img_OB, "BestObjectness", len(pred_dict_OB["annList"])), rescale_image(img_blobs, "Blobs", len(pred_dict_blobs["annList"])), rescale_image(img_dice, "BestDice", len(pred_dict_dice["annList"]))], axis=axis) if return_image: return imgAll else: ms.images(imgAll, win="image: {} (1) GT - (2) Blobs - (3) BestDice".format(batch["index"][0]))
def visBaselines(batch, win="", return_image=False): if 1: # Preds pred_dict_obj = au.pointList2BestObjectness(batch["lcfcn_pointList"], batch) pred_dict_uB = au.pointList2UpperBound(batch["lcfcn_pointList"], batch) img_points = get_image_points(batch) img_obj = ms.get_image(img_points, au.annList2mask(pred_dict_obj["annList"], color=1)["mask"]) img_ub = ms.get_image(img_points, au.annList2mask(pred_dict_uB["annList"], color=1)["mask"]) img_points = rescale_image(img_points, "Original") if img_points.shape[-1] > img_points.shape[-2]: axis = 1 else: axis = 0 imgAll = np.concatenate([img_points, rescale_image(img_obj, "BestObjectness", len(pred_dict_obj["annList"])), rescale_image(img_ub, "UpperBound",len(pred_dict_uB["annList"]))], axis=axis) if return_image: return imgAll else: ms.images(imgAll, win=("image: {} - counts: {} (1) GT" " - (2) BestObjectness" " - (3) UpperBound".format(batch["index"][0], len(batch["lcfcn_pointList"]))))
def visualize(self, batch, cam_index=None): cam = ms.resizeTo(self.forward_cam(batch["images"].cuda()),batch["images"]) preds = self.predict(batch, "counts") print(preds) if cam_index is None: cam_index = preds["indices"][0] image_points = ms.get_image(batch["images"], (batch["points"]==(cam_index+1)).long(), denorm=1, enlarge=1) ms.images(image_points[0], ms.gray2cmap(ms.t2n(cam[:,cam_index])))
def old_visSplit(model, batch, split_mode="water", win="split"): image = ms.denormalize(batch["images"]) image = ms.f2l(ms.t2n(image)).squeeze() probs = ms.t2n(model.predict(batch, "probs").squeeze()[1]) points =ms.t2n(batch["points"].squeeze()) # if "blobs" in split_mode: # # probs[probs < 0.5] = 0 # points[probs < 0.5] = 0 if split_mode == "water" or split_mode == "water_blobs": split_matrix = splits.watersplit(probs, points) elif split_mode == "line": split_matrix = 1 - splits.line_splits(probs, points) elif split_mode == "line_blobs": # eqwe blob_dict = l_helpers.get_blob_dict(model, batch) split_matrix = np.zeros(points.shape, int) for b in blob_dict["blobList"]: if b["n_points"] < 2: continue points_class = (points==(b["class"] + 1)).astype("int") blob_ind = blob_dict["blobs"][b["class"] ] == b["label"] # print((blob_ind).sum()) splitss = 1 - splits.line_splits(probs*blob_ind, points_class*blob_ind) split_matrix += splitss*blob_ind # if "blobs" in split_mode: # split_matrix[probs < 0.5] = 0 # print(split_matrix.shape) print(split_matrix.max()) split_img = ms.get_image(ms.l2f(image)[None], split_matrix.squeeze()[None].astype(int)) #print(image.shape) ms.images(split_img, points, enlarge=True, win=win)
def visBlobs_old(model, batch, win="", predict_method="blobs", cocoGt=None, return_image=False, split=False): pred_dict = model.predict(batch, predict_method=predict_method) for i, c in enumerate(pred_dict["counts"].ravel()): if c == 0: continue gt_count = batch["counts"].squeeze()[i] print("# blobs class {}: P: {} - GT:{}".format(i+1, int(c),gt_count)) print("True Classes:", batch["points"].unique()) img_points = get_image_points(batch) if cocoGt is not None: # print(batch["image_id"][0]) try: annList = cocoGt.imgToAnns[batch["image_id"][0].item()] except: annList = cocoGt.imgToAnns[batch["image_id"][0]] # print(annList) # print(au.annList2mask(cocoGt.imgToAnns[batch["image_id"][0].item()])["mask"]) ms.images(img_points, au.annList2mask(annList)["mask"], win="gt {}".format(win)) if return_image: return ms.get_image(img_points, pred_dict["blobs"]) else: ms.images(img_points, pred_dict["blobs"], win="blobs {}".format(win)) if predict_method not in [None, "blobs"] and not return_image: pred_dict = model.predict(batch, predict_method='blobs') ms.images(img_points, pred_dict["blobs"], win="pure blobs {}".format(win)) if split: print(pred_dict.keys()) ms.images(img_points, 1-au.probs2splitMask_all(pred_dict["probs"], pointList=au.points2pointList(batch["points"])["pointList"])["maskList"][0]["mask"], win="split")
def visBlobs(model, batch, win="", predict_method="BestDice", return_image=False): if 1: # Preds pred_dict_dice = model.predict(batch, predict_method=predict_method) # Counts count_diff(pred_dict_dice, batch) img_points = get_image_points(batch) dice_dict = au.annList2mask(pred_dict_dice["annList"], color=1) img_dice = ms.get_image(img_points, dice_dict["mask"]) img_points = rescale_image(img_points, "Original", n_preds=batch["counts"].sum().item()) imgAll = rescale_image(img_dice, "BestDice", len(pred_dict_dice["annList"])) if return_image: return imgAll else: ms.images(imgAll, win="image: {} (1) GT - (2) Blobs - (3) BestDice".format(batch["index"][0]))
def test_model(main_dict, reset=None): # pointDict = load_LCFCNPoints(main_dict) _, val_set = load_trainval(main_dict) model = ms.load_best_model(main_dict) gt_annDict = load_gtAnnDict(main_dict) # for i in range(50): import ipdb; ipdb.set_trace() # breakpoint 887ad390 // if 1: b_list = [23] for i in b_list: batch = ms.get_batch(val_set, [i]) annList_ub = pointList2UpperBoundMask(batch["lcfcn_pointList"], batch)["annList"] annList_bo = pointList2BestObjectness(batch["lcfcn_pointList"], batch)["annList"] annList = model.predict(batch, predict_method="BestDice")["annList"] results = get_perSizeResults(gt_annDict, annList) print(i,"Counts:", batch["counts"].item(), " - BestObjectness:", len(annList_bo), " - Model:", len(annList), " - UpperBound", len(annList_ub)) print(i, get_perSizeResults(gt_annDict, annList_bo, pred_images_only=1)["result_dict"]["0.25"], get_perSizeResults(gt_annDict, annList, pred_images_only=1)["result_dict"]["0.25"], get_perSizeResults(gt_annDict, annList_ub, pred_images_only=1)["result_dict"]["0.25"]) import ipdb; ipdb.set_trace() # breakpoint 98d0193a // image_points = ms.get_image(batch["images"], batch["points"], enlarge=1,denorm=1) ms.images(image_points, annList2mask(annList)["mask"], win="model prediction") ms.images(batch["images"], annList2mask(annList_bo)["mask"],win="2", denorm=1) ms.images(batch["images"], annList2mask(annList_ub)["mask"], win="3", denorm=1) ms.images(batch["images"], batch["points"], win="4", enlarge=1,denorm=1) ms.images(batch["images"], model.predict(batch, predict_method="points")["blobs"], win="5", enlarge=1,denorm=1) ms.images(batch["images"], pointList2points(batch["lcfcn_pointList"])["mask"], win="predicted_points", enlarge=1,denorm=1) fname = main_dict["path_baselines"].replace("baselines", main_dict["model_name"]) if reset == "reset": _, val_set = load_trainval(main_dict) history = ms.load_history(main_dict) import ipdb; ipdb.set_trace() # breakpoint a769ce6e // model = ms.load_best_model(main_dict) pred_annList = dataset2annList(model, val_set, predict_method="BestDice", n_val=None) pred_annList_up = load_predAnnList(main_dict, predict_method="UpperBoundMask") pred_annList_up = load_predAnnList(main_dict, predict_method="UpperBound") gt_annDict = load_gtAnnDict(main_dict) results = get_perSizeResults(gt_annDict, pred_annList) result_dict = results["result_dict"] result_dict["Model"] = main_dict["model_name"] result_list = [result_dict] ms.save_pkl(fname, result_list) else: result_list = ms.load_pkl(fname) return result_list
def main(): parser = argparse.ArgumentParser() parser.add_argument('-e', '--exp') parser.add_argument('-b', '--borgy', default=0, type=int) parser.add_argument('-br', '--borgy_running', default=0, type=int) parser.add_argument('-m', '--mode', default="summary") parser.add_argument('-r', '--reset', default="None") parser.add_argument('-s', '--status', type=int, default=0) parser.add_argument('-k', '--kill', type=int, default=0) parser.add_argument('-g', '--gpu', type=int) parser.add_argument('-c', '--configList', nargs="+", default=None) parser.add_argument('-l', '--lossList', nargs="+", default=None) parser.add_argument('-d', '--datasetList', nargs="+", default=None) parser.add_argument('-metric', '--metricList', nargs="+", default=None) parser.add_argument('-model', '--modelList', nargs="+", default=None) parser.add_argument('-p', '--predictList', nargs="+", default=None) args = parser.parse_args() if args.borgy or args.kill: global_prompt = input("Do all? \n(y/n)\n") # SEE IF CUDA IS AVAILABLE assert torch.cuda.is_available() print("CUDA: %s" % torch.version.cuda) print("Pytroch: %s" % torch.__version__) mode = args.mode exp_name = args.exp exp_dict = experiments.get_experiment_dict(args, exp_name) pp_main = None results = {} # Get Main Class project_name = os.path.realpath(__file__).split("/")[-2] MC = ms.MainClass(path_models="models", path_datasets="datasets", path_metrics="metrics/metrics.py", path_losses="losses/losses.py", path_samplers="addons/samplers.py", path_transforms="addons/transforms.py", path_saves="/mnt/projects/counting/Saves/main/", project=project_name) key_set = set() for model_name, config_name, metric_name, dataset_name, loss_name in product( exp_dict["modelList"], exp_dict["configList"], exp_dict["metricList"], exp_dict["datasetList"], exp_dict["lossList"]): # if model_name in ["LC_RESFCN"]: # loss_name = "water_loss" config = configs.get_config_dict(config_name) key = ("{} - {} - {}".format(model_name, config_name, loss_name), "{}_({})".format(dataset_name, metric_name)) if key in key_set: continue key_set.add(key) main_dict = MC.get_main_dict(mode, dataset_name, model_name, config_name, config, args.reset, exp_dict["epochs"], metric_name, loss_name) main_dict["predictList"] = exp_dict["predictList"] if mode == "paths": print("\n{}_({})".format(dataset_name, model_name)) print(main_dict["path_best_model"]) # print( main_dict["exp_name"]) predictList_str = ' '.join(exp_dict["predictList"]) if args.status: results[key] = borgy.borgy_status(mode, config_name, metric_name, model_name, dataset_name, loss_name, args.reset, predictList_str) continue if args.kill: results[key] = borgy.borgy_kill(mode, config_name, metric_name, model_name, dataset_name, loss_name, args.reset, predictList_str) continue if args.borgy: results[key] = borgy.borgy_submit(project_name, global_prompt, mode, config_name, metric_name, model_name, dataset_name, loss_name, args.reset, predictList_str) continue if mode == "debug": debug.debug(main_dict) if mode == "validate": validate.validate(main_dict) if mode == "save_gam_points": train_set, _ = au.load_trainval(main_dict) model = ms.load_best_model(main_dict) for i in range(len(train_set)): print(i, "/", len(train_set)) batch = ms.get_batch(train_set, [i]) fname = train_set.path + "/gam_{}.pkl".format( batch["index"].item()) points = model.get_points(batch) ms.save_pkl(fname, points) import ipdb ipdb.set_trace() # breakpoint ee49ab9f // if mode == "save_prm_points": train_set, _ = au.load_trainval(main_dict) model = ms.load_best_model(main_dict) for i in range(len(train_set)): print(i, "/", len(train_set)) batch = ms.get_batch(train_set, [i]) fname = "{}/prm{}.pkl".format(batch["path"][0], batch["name"][0]) points = model.get_points(batch) ms.save_pkl(fname, points) import ipdb ipdb.set_trace() # breakpoint 679ce152 // # train_set, _ = au.load_trainval(main_dict) # model = ms.load_best_model(main_dict) # for i in range(len(train_set)): # print(i, "/", len(train_set)) # batch = ms.get_batch(train_set, [i]) # fname = train_set.path + "/gam_{}.pkl".format(batch["index"].item()) # points = model.get_points(batch) # ms.save_pkl(fname, points) # if mode == "pascal_annList": # data_utils.pascal2lcfcn_points(main_dict) if mode == "upperboundmasks": import ipdb ipdb.set_trace() # breakpoint 02fac8ce // results = au.test_upperboundmasks(main_dict, reset=args.reset) print(pd.DataFrame(results)) if mode == "model": results = au.test_model(main_dict, reset=args.reset) print(pd.DataFrame(results)) if mode == "upperbound": results = au.test_upperbound(main_dict, reset=args.reset) print(pd.DataFrame(results)) if mode == "MUCov": gtAnnDict = au.load_gtAnnDict(main_dict, reset=args.reset) # model = ms.load_best_model(main_dict) fname = main_dict["path_save"] + "/pred_annList.pkl" if not os.path.exists(fname): _, val_set = au.load_trainval(main_dict) model = ms.load_best_model(main_dict) pred_annList = au.dataset2annList(model, val_set, predict_method="BestDice", n_val=None) ms.save_pkl(fname, pred_annList) else: pred_annList = ms.load_pkl(fname) import ipdb ipdb.set_trace() # breakpoint 527a7f36 // pred_annList = au.load_predAnnList(main_dict, predict_method="BestObjectness") # 0.31 best objectness pred_annList = # 0.3482122335421256 # au.get_MUCov(gtAnnDict, pred_annList) au.get_SBD(gtAnnDict, pred_annList) if mode == "dic_sbd": import ipdb ipdb.set_trace() # breakpoint 4af08a17 // if mode == "point_mask": from datasets import base_dataset import ipdb ipdb.set_trace() # breakpoint 7fd55e0c // _, val_set = ms.load_trainval(main_dict) batch = ms.get_batch(val_set, [1]) model = ms.load_best_model(main_dict) pred_dict = model.LCFCN.predict(batch) # ms.pretty_vis(batch["images"], base_dataset.batch2annList(batch)) ms.images(ms.pretty_vis( batch["images"], model.LCFCN.predict(batch, predict_method="original")["annList"]), win="blobs") ms.images(ms.pretty_vis(batch["images"], base_dataset.batch2annList(batch)), win="erww") ms.images(batch["images"], batch["points"], denorm=1, enlarge=1, win="e21e") import ipdb ipdb.set_trace() # breakpoint ab9240f0 // if mode == "lcfcn_output": import ipdb ipdb.set_trace() # breakpoint 7fd55e0c // gtAnnDict = au.load_gtAnnDict(main_dict, reset=args.reset) if mode == "load_gtAnnDict": _, val_set = au.load_trainval(main_dict) gtAnnDict = au.load_gtAnnDict(val_set) # gtAnnClass = COCO(gtAnnDict) # au.assert_gtAnnDict(main_dict, reset=None) # _,val_set = au.load_trainval(main_dict) # annList_path = val_set.annList_path # fname_dummy = annList_path.replace(".json","_best.json") # predAnnDict = ms.load_json(fname_dummy) import ipdb ipdb.set_trace() # breakpoint 100bfe1b // pred_annList = ms.load_pkl(main_dict["path_best_annList"]) # model = ms.load_best_model(main_dict) _, val_set = au.load_trainval(main_dict) batch = ms.get_batch(val_set, [1]) import ipdb ipdb.set_trace() # breakpoint 2310bb33 // model = ms.load_best_model(main_dict) pred_dict = model.predict(batch, "BestDice", "mcg") ms.images(batch["images"], au.annList2mask(pred_dict["annList"])["mask"], denorm=1) # pointList2UpperBoundMCG pred_annList = au.load_predAnnList(main_dict, predict_method="BestDice", proposal_type="mcg", reset="reset") # annList = au.pointList2UpperBoundMCG(batch["lcfcn_pointList"], batch)["annList"] ms.images(batch["images"], au.annList2mask(annList)["mask"], denorm=1) pred_annList = au.load_BestMCG(main_dict, reset="reset") # pred_annList = au.dataset2annList(model, val_set, # predict_method="BestDice", # n_val=None) au.get_perSizeResults(gtAnnDict, pred_annList) if mode == "vis": _, val_set = au.load_trainval(main_dict) batch = ms.get_batch(val_set, [3]) import ipdb ipdb.set_trace() # breakpoint 05e6ef16 // vis.visBaselines(batch) model = ms.load_best_model(main_dict) vis.visBlobs(model, batch) if mode == "qual": model = ms.load_best_model(main_dict) _, val_set = au.load_trainval(main_dict) path = "/mnt/home/issam/Summaries/{}_{}".format( dataset_name, model_name) try: ms.remove_dir(path) except: pass n_images = len(val_set) base = "{}_{}".format(dataset_name, model_name) for i in range(50): print(i, "/10", "- ", base) index = np.random.randint(0, n_images) batch = ms.get_batch(val_set, [index]) if len(batch["lcfcn_pointList"]) == 0: continue image = vis.visBlobs(model, batch, return_image=True) # image_baselines = vis.visBaselines(batch, return_image=True) # imgAll = np.concatenate([image, image_baselines], axis=1) fname = path + "/{}_{}.png".format(i, base) ms.create_dirs(fname) ms.imsave(fname, image) if mode == "test_baselines": import ipdb ipdb.set_trace() # breakpoint b51c5b1f // results = au.test_baselines(main_dict, reset=args.reset) print(pd.DataFrame(results)) if mode == "test_best": au.test_best(main_dict) if mode == "qualitative": au.qualitative(main_dict) if mode == "figure1": from PIL import Image from addons import transforms model = ms.load_best_model(main_dict) _, val_set = au.load_trainval(main_dict) # proposals_path = "/mnt/datasets/public/issam/Cityscapes/demoVideo/leftImg8bit/demoVideo/ProposalsSharp/" # vidList = glob("/mnt/datasets/public/issam/Cityscapes/demoVideo/leftImg8bit/demoVideo/stuttgart_01/*") # vidList.sort() # pretty_image = ms.visPretty(model, batch = ms.get_batch(val_set, [i]), with_void=1, win="with_void") batch = ms.get_batch(val_set, [68]) bestdice = ms.visPretty(model, batch=batch, with_void=0, win="no_void") blobs = ms.visPretty(model, batch=batch, predict_method="blobs", with_void=0, win="no_void") ms.images(bestdice, win="BestDice") ms.images(blobs, win="Blobs") ms.images(batch["images"], denorm=1, win="Image") ms.images(batch["images"], batch["points"], enlarge=1, denorm=1, win="Points") import ipdb ipdb.set_trace() # breakpoint cf4bb3d3 // if mode == "video2": from PIL import Image from addons import transforms model = ms.load_best_model(main_dict) _, val_set = au.load_trainval(main_dict) # proposals_path = "/mnt/datasets/public/issam/Cityscapes/demoVideo/leftImg8bit/demoVideo/ProposalsSharp/" # vidList = glob("/mnt/datasets/public/issam/Cityscapes/demoVideo/leftImg8bit/demoVideo/stuttgart_01/*") # vidList.sort() index = 0 for i in range(len(val_set)): # pretty_image = ms.visPretty(model, batch = ms.get_batch(val_set, [i]), with_void=1, win="with_void") batch = ms.get_batch(val_set, [i]) pretty_image = ms.visPretty(model, batch=batch, with_void=0, win="no_void") # pred_dict = model.predict(batch, predict_method="BestDice") path_summary = main_dict["path_summary"] ms.create_dirs(path_summary + "/tmp") ms.imsave( path_summary + "vid_mask_{}.png".format(index), ms.get_image(batch["images"], batch["points"], enlarge=1, denorm=1)) index += 1 ms.imsave(path_summary + "vid_mask_{}.png".format(index), pretty_image) index += 1 # ms.imsave(path_summary+"vid1_full_{}.png".format(i), ms.get_image(img, pred_dict["blobs"], denorm=1)) print(i, "/", len(val_set)) if mode == "video": from PIL import Image from addons import transforms model = ms.load_best_model(main_dict) # _, val_set = au.load_trainval(main_dict) proposals_path = "/mnt/datasets/public/issam/Cityscapes/demoVideo/leftImg8bit/demoVideo/ProposalsSharp/" vidList = glob( "/mnt/datasets/public/issam/Cityscapes/demoVideo/leftImg8bit/demoVideo/stuttgart_01/*" ) vidList.sort() for i, img_path in enumerate(vidList): image = Image.open(img_path).convert('RGB') image = image.resize((1200, 600), Image.BILINEAR) img, _ = transforms.Tr_WTP_NoFlip()([image, image]) pred_dict = model.predict( { "images": img[None], "split": ["test"], "resized": torch.FloatTensor([1]), "name": [ms.extract_fname(img_path)], "proposals_path": [proposals_path] }, predict_method="BestDice") path_summary = main_dict["path_summary"] ms.create_dirs(path_summary + "/tmp") ms.imsave(path_summary + "vid1_mask_{}.png".format(i), ms.get_image(pred_dict["blobs"])) ms.imsave(path_summary + "vid1_full_{}.png".format(i), ms.get_image(img, pred_dict["blobs"], denorm=1)) print(i, "/", len(vidList)) if mode == "5_eval_BestDice": gtAnnDict = au.load_gtAnnDict(main_dict) gtAnnClass = COCO(gtAnnDict) results = au.assert_gtAnnDict(main_dict, reset=None) if mode == "cp_annList": ms.dataset2cocoformat(dataset_name="CityScapes") if mode == "pascal2lcfcn_points": data_utils.pascal2lcfcn_points(main_dict) if mode == "cp2lcfcn_points": data_utils.cp2lcfcn_points(main_dict) if mode == "train": train.main(main_dict) import ipdb ipdb.set_trace() # breakpoint a5d091b9 // if mode == "train_only": train.main(main_dict, train_only=True) import ipdb ipdb.set_trace() # breakpoint a5d091b9 // if mode == "sharpmask2psfcn": for split in ["train", "val"]: root = "/mnt/datasets/public/issam/COCO2014/ProposalsSharp/" path = "{}/sharpmask/{}/jsons/".format(root, split) jsons = glob(path + "*.json") propDict = {} for k, json in enumerate(jsons): print("{}/{}".format(k, len(jsons))) props = ms.load_json(json) for p in props: if p["image_id"] not in propDict: propDict[p["image_id"]] = [] propDict[p["image_id"]] += [p] for k in propDict.keys(): fname = "{}/{}.json".format(root, k) ms.save_json(fname, propDict[k]) if mode == "cp2coco": import ipdb ipdb.set_trace() # breakpoint f2eb9e70 // dataset2cocoformat.cityscapes2cocoformat(main_dict) # train.main(main_dict) import ipdb ipdb.set_trace() # breakpoint a5d091b9 // if mode == "train_lcfcn": train_lcfcn.main(main_dict) import ipdb ipdb.set_trace() # breakpoint a5d091b9 // if mode == "summary": try: history = ms.load_history(main_dict) # if predictList_str == "MAE": # results[key] = "{}/{}: {:.2f}".format(history["best_model"]["epoch"], # history["epoch"], # history["best_model"][metric_name]) # else: val_dict = history["val"][-1] val_dict = history["best_model"] iou25 = val_dict["0.25"] iou5 = val_dict["0.5"] iou75 = val_dict["0.75"] results[key] = "{}/{}: {:.1f} - {:.1f} - {:.1f}".format( val_dict["epoch"], history["epoch"], iou25 * 100, iou5 * 100, iou75 * 100) # if history["val"][-1]["epoch"] != history["epoch"]: # results[key] += " | Val {}".format(history["epoch"]) try: results[key] += " | {}/{}".format( len(history["trained_batch_names"]), history["train"][-1]["n_samples"]) except: pass except: pass if mode == "vals": history = ms.load_history(main_dict) for i in range(1, len(main_dict["predictList"]) + 1): if len(history['val']) == 0: res = "NaN" continue else: res = history["val"][-i] map50 = res["map50"] map75 = res["map75"] # if map75 < 1e-3: # continue string = "{} - {} - map50: {:.2f} - map75: {:.2f}".format( res["epoch"], res["predict_name"], map50, map75) key_tmp = list(key).copy() key_tmp[1] += " {} - {}".format(metric_name, res["predict_name"]) results[tuple(key_tmp)] = string # print("map75", pd.DataFrame(history["val"])["map75"].max()) # df = pd.DataFrame(history["vals"][:20])["water_loss_B"] # print(df) try: print(ms.dict2frame(results)) except: print("Results not printed...")
def get_image_points(batch): img = ms.denormalize(batch["images"]) img_points = ms.get_image(img, mask=batch["points"], enlarge=1) return img_points
def old_visBlobs(model, batch, win="9999", label=0, enlarge=0, return_dict=False, training=False, split=None, color_types=False, which=0): batch = ms.copy.deepcopy(batch) image = batch["images"] points = batch["points"][0] counts = ms.t2n(batch["counts"][0]) denormed_img = ms.denormalize(image) p_probs = ms.t2n(model.predict(batch, metric="probs"))[0] p_blobs = model.predict(batch, "blobs", training) p_blobs = p_blobs[0] import ipdb; ipdb.set_trace() # breakpoint c749dcc0 // p_counts = p_blobs.max((1,2)) if p_blobs.shape[0] > 1: p_blobs = p_blobs[p_counts!=0] p_blobs = p_blobs[which] # p_blobs = p_blobs[p_counts!=0] if p_counts.size > counts.size: counts = counts.repeat(p_counts.size) for i in range(p_counts.size): if int(counts[i]) == 0: continue sting = "class: %d: True-Pred: %d-%d" % (i, int(counts[i]), int(p_counts[i])) if not return_dict: print(sting) if split is not None: from addons import vis vis.visSplit(model, batch, split_mode=split) if color_types: p_blobs = colorBlobs(points, p_blobs) img_points = ms.get_image(denormed_img, mask=points, enlarge=1) img_blobs = ms.get_image(denormed_img, mask=p_blobs) img_combined = ms.get_image(img_points, mask=p_blobs) if return_dict: return {"images":denormed_img, "with_blobs":img_blobs, "with_points":img_points, "combined":img_combined, "p_counts":p_counts, "counts":counts} else: title = "" print(title) ms.images(denormed_img, title=title+"Images", win=win+"0") ms.images(img_points, title=title+"Points", win=win+"1") ms.images(img_blobs, title=title+"Blobs", win=win+"2")