def prepare_nori(self, cfg): self.use_nori = cfg.USE_NORI if not self.use_nori: return split_name = "train2017" if self.is_train else "val2017" self.image_fetcher = NoriRedis( cfg, smart_path(cfg.NORI_PATH).joinpath(split_name + ".nori").as_uri()) if self.need_masks: self.sizes_fecher = NoriRedis( cfg, smart_path(cfg.NORI_PATH).joinpath(split_name + "_sizes.nori").as_uri())
def test_rle_to_polygon(res_file): obj365_anno_file = "datasets/obj365/annotations/objects365_val_20190423.json" obj_api = COCO(annotation_file=obj365_anno_file) with open(file=res_file, mode='rb') as f: predictions = torch.load(f) anns = list(itertools.chain(*[x["instances"] for x in predictions])) oss_root = "s3://detection/objects365_raw_data/objects365/val/" img_format = "BGR" for ann in anns: segm = ann['segmentation'] image_dict = obj_api.imgs[ann['image_id']] file_path = os.path.join(oss_root, image_dict['file_name']) image = load_image_from_oss(smart_path(file_path), format=img_format) image = convert_image_to_rgb(image, format=img_format) v_rle = Visualizer(image, None) v_rle = v_rle.overlay_instances(masks=[segm], ) v_rle.save('/data/tmp/{}_rle.png'.format(ann['image_id'])) v_polygon = Visualizer(copy.deepcopy(image), None) v_polygon = v_polygon.overlay_instances( masks=[_convert_rle_to_polygon(segm)], ) v_polygon.save('/data/tmp/{}_polygon.png'.format(ann['image_id'])) ipdb.set_trace()
def masks_for_image(self, dataset_dict, transforms): image_name = smart_path(dataset_dict["file_name"]).name masks = dict() for key in self.mask_keys: data = self.sizes_fecher.fetch(image_name) image = np.fromstring(data, dtype=np.float32) if key == "sizes": image = image.reshape( (dataset_dict["height"], dataset_dict["width"], 2)) image = image.transpose(2, 0, 1) resize_tfm = transforms.transforms[0] assert isinstance(resize_tfm, T.ResizeTransform) ratio_h = resize_tfm.new_h / resize_tfm.h ratio_w = resize_tfm.new_w / resize_tfm.w image = np.stack( [ transforms.apply_image(image[0] * ratio_w), transforms.apply_image(image[1] * ratio_h), ], axis=0, ) else: image = image.reshape( (dataset_dict["height"], dataset_dict["width"])) image = transforms.apply_image(image) masks[key] = torch.as_tensor(np.ascontiguousarray(image.copy())) del image return masks
def main(): parser = default_argument_parser() parser.add_argument("--prediction", help="predictions_file_path") args = parser.parse_args() cfg = setup(args) with smart_path(args.prediction).open("rb") as fp: buf = io.BytesIO(fp.read()) predictions = torch.load(buf) pred_by_image = defaultdict(list) for p in predictions: pred_by_image[p["image_id"]].append(p) dataset = cfg.DATASETS.TEST[0] metadata = MetadataCatalog.get(dataset) if hasattr(metadata, "thing_dataset_id_to_contiguous_id"): def dataset_id_map(ds_id): return metadata.thing_dataset_id_to_contiguous_id[ds_id] output_folder = os.path.join(cfg.OUTPUT_DIR, "inference") evaluator = COCOEvaluator(dataset, cfg, False, output_folder) evaluator.reset() dicts = list(DatasetCatalog.get(dataset)) count = 0 for dic in tqdm.tqdm(dicts): #assert len(pred_by_image[dic["image_id"]]) == 1, str(dic["image_id"]) if len(pred_by_image[dic["image_id"]]) == 0: continue prediction = pred_by_image[dic["image_id"]][0] prediction = create_instances(prediction, (dic["height"], dic["width"])) # Push an image dic["annotations"] = reconstruct_ann(dic["annotations"]) evaluator.process([dic], [{"instances": prediction}]) count += 1 result = evaluator.evaluate() prediction_path = smart_path(args.prediction) save_path = prediction_path.parent.joinpath(prediction_path.stem + ".pkl") with save_path.open("wb") as writer: pickle.dump(result, writer) print_csv_format(result)
def target(self, queue): path = smart_path(self.path) with nr.open(path.as_uri(), "w") as writer: while True: content = queue.get() if content is None: break writer.put(content[0], filename=[content[1]]) if self.after is not None: self.after()
def read_image(self, file_name): #uods = _whether_use_oss_data_source(file_name) # use_oss_data_source if self.uods: # set oss bucket name like: s3://detections/ file_path = smart_path(os.path.join(self.oss_root, file_name)) image = load_image_from_oss(file_path, format=self.image_format) else: image = utils.read_image(file_name, format=self.image_format) return image
def fetch(self, file_name, fetcher=None): import nori2 as nr data_id = self.get(smart_path(file_name).name) if fetcher is None: if self.fechcer is None: self.fechcer = nr.Fetcher() fetcher = self.fechcer return fetcher.get(data_id)
def main(input_path, coco_json_path, output_path): origin_dict = json.load(smart_path(input_path).open("rt")) coco_dict = json.load(smart_path(coco_json_path).open("rt")) origin_coco = COCO(input_path) coco = COCO(coco_json_path) anns = [] images = list() image_ids = set() for ann in origin_dict["annotations"]: ratio = COCO.compute_ratio(ann)["ratio"] if ratio > 1 / 3: continue ann["ratio"] = ratio ann["id"] = ann["id"] + 1 << 31 image_id = ann["image_id"] + 1 << 31 image = origin_coco.imgs[ann["image_id"]] image["id"] = image_id ann["image_id"] = image_id anns.append(ann) if not image_id in image_ids: images.append(image) image_ids.add(image_id) info = dict(date_created=str(datetime.datetime.now()), description="Merged from {} and {}.".format( input_path, coco_json_path)) new_coco_dict = dict(info=copy.deepcopy(info), categories=copy.deepcopy(coco_dict["categories"]), licenses=None, annotations=copy.deepcopy(coco_dict["annotations"]) + copy.deepcopy(anns), images=copy.deepcopy(coco_dict["images"]) + copy.deepcopy(images)) with open(output_path, "wt") as writer: json.dump(new_coco_dict, writer)
def save(rgb: np.ndarray, mask: np.ndarray, centers: np.ndarray, *file_names): assert len(file_names) > 0 rgb_save_path = smart_path(os.path.join(file_names[0], file_names[1])) mask_save_path = smart_path(os.path.join(file_names[0], file_names[2])) if not exists(rgb_save_path): mknod(rgb_save_path) if not exists(mask_save_path): mknod(mask_save_path) im_rgb = Image.fromarray(rgb) im_rgb.save(rgb_save_path) mask = cv2.applyColorMap(mask, 0) im_mask = Image.fromarray(mask) draw = ImageDraw.Draw(im_mask) radis = 2 for i in range(len(centers)): draw.pieslice((centers[i, 0] - radis, centers[i, 1] - radis, centers[i, 0] + radis, centers[i, 1] + radis), start=0, end=360, fill=128) im_mask.save(mask_save_path)
def main(dest_dir="s3://detection/benchmarking/inference/"): dest_dir = smart_path(dest_dir) while True: for prediction_path in dest_dir.glob("*.pth"): command = "rlaunch --cpu 2 --memory $((10*1024)) -- python3 -m " \ "tools.result_statistic --config-file configs/retina/base_retina_R_50_FPN_1x.yaml " \ "--prediction {}".format(prediction_path.as_uri()) print(command) code = os.system(command) print(code) if code == 0: prediction_path.rename( dest_dir.joinpath("archived", prediction_path.name)) else: print("Error for {}, will retry in 10 secs".format(prediction_path.as_uri())) print("Dir {} is clean, sleep for 10 secs.".format(dest_dir.as_uri())) time.sleep(10)
def test_dataset_dicts(): dataset_dicts = get_detection_dataset_dicts( ['coco_objects365_val_with_masks'], filter_empty=False, ) oss_root = "s3://detection/" img_format = "BGR" for dataset_dict in dataset_dicts: file_path = os.path.join(oss_root, dataset_dict['file_name']) image = load_image_from_oss(smart_path(file_path), format=img_format) image = convert_image_to_rgb(image, format=img_format) anns = dataset_dict['annotations'] masks = [ann['segmentation'] for ann in anns] v_gt = Visualizer(image, None) v_gt = v_gt.overlay_instances(masks=masks, ) v_gt.save('/data/tmp/test_dd_{}.png'.format(dataset_dict['image_id'])) ipdb.set_trace()
all_count = 0 empty_count = 0 problematic_count = 0 for dic in tqdm.tqdm(dicts): for obj in dic["annotations"]: all_count += 1 if not "segmentation" in obj or len(obj["segmentation"]) == 0: empty_count += 1 continue try: segmentations = PolygonMasks([obj["segmentation"]]) ratio = segmentations.get_ratios(oriented=True)[0] print(ratio) except: problematic_count += 1 ratio = COCO.compute_ratio(obj) img = utils.convert_PIL_to_numpy( Image.open( io.BytesIO( smart_path("s3://detection/" + dic["file_name"]).read_bytes())), "RGB") visualizer = Visualizer(img, metadata=metadata, scale=scale) vis = visualizer.draw_dataset_dict(dic) output(vis, os.path.basename(dic["file_name"])) print("all", all_count) print("empty", empty_count) print("problematic", problematic_count)
def main( result_path="train_log/retinanet/R_50_FPN/baseline/inference/instances_predictions_coco.pkl", result_path_2="../train_log/retinanet/R_50_FPN/baseline/inference/coco_objects365_val_with_masks/instances_predictions.pkl"): result_path = smart_path(result_path) results = pickle.loads(result_path.read_bytes()) result_path_2 = smart_path(result_path_2) results_2 = pickle.loads(result_path_2.read_bytes()) # shape (T, K, R, A), where T, K, R, A are number of thresholds, # classes, ratios, areas, respectively. ar = results["ar"] stats = results["ar"]["ar-stats"]["recalls"] * 100 ar_2 = results_2["ar"] stats_2 = results_2["ar"]["ar-stats"]["recalls"] * 100 plt.style.use(['ieee', "no-latex"]) fig, axs = plt.subplots(3, 3, sharey=True, figsize=(9, 9)) markers = ['*', '_', '+', 'x'] # plot overall AR xs = np.arange(4) + 1 ys = np.array([ar["AR@100"], ar["AR- 0 - 1/5@100"], ar["AR-1/5 - 1/3@100"], ar["AR-1/3 - 3/1@100"]]) scatter_with_markers(axs[0, 0], xs, ys, markers, c="r") axs[0, 0].plot(xs, ys, linestyle="dotted") axs[0, 0].set_xticks(xs) title(axs[0, 0], "all objects") axs[0, 0].set_ylabel("mAR-COCO") axs[0, 0].set_xlabel("slenderness") axs[0, 0].set_xticklabels(["all", "XS", "S", "R"]) # merge [ax.remove() for ax in axs[0, 1:]] ax = fig.add_subplot(axs[0, 2].get_gridspec()[0, 1:]) # plot thresholds T = stats.shape[0] xs = np.array([1]) x_labels = [] thresh = 0.5 stride = 0.05 xticks = [] for i in range(T): ys = stats[i, :-1, 0:4, 0].mean(0) xs = np.arange(4) + xs.max() + 1 scatter_with_markers(ax, xs, ys, markers, c='r') ax.plot(xs, ys, c='black', linestyle="dotted") x_labels += ["", str(int(thresh * 100) / 100), "", ""] thresh += stride xticks.append(xs) ax.set_xticks(np.concatenate(xticks)) ax.set_xticklabels(x_labels) title(ax, "all objects") ax.set_xlabel("threshold") ax.legend( [Line2D([0], [0], color="b", linewidth=1, linestyle="none", marker=m, c="r") for m in markers], ["all", "XS", "S", "R"], loc="upper right") # plot overall AR xs = np.arange(4) + 1 ys = np.array([ar_2["AR@100"], ar_2["AR- 0 - 1/5@100"], ar_2["AR-1/5 - 1/3@100"], ar_2["AR-1/3 - 3/1@100"]]) ax = axs[1, 0] scatter_with_markers(ax, xs, ys, markers, c="g") ax.plot(xs, ys, linestyle="dotted") ax.set_xticks(xs) title(ax, "all objects") ax.set_ylabel("mAR-COCO+") ax.set_xlabel("slenderness") ax.set_xticklabels(["all", "XS", "S", "R"]) # merge [ax.remove() for ax in axs[1, 1:]] ax = fig.add_subplot(axs[1, 2].get_gridspec()[1, 1:]) # plot thresholds T = stats.shape[0] xs = np.array([1]) x_labels = [] thresh = 0.5 stride = 0.05 xticks = [] for i in range(T): ys = stats_2[i, :-1, 0:4, 0].mean(0) xs = np.arange(4) + xs.max() + 1 scatter_with_markers(ax, xs, ys, markers, c='g') ax.plot(xs, ys, c='black', linestyle="dotted") x_labels += ["", str(int(thresh * 100) / 100), "", ""] thresh += stride xticks.append(xs) ax.set_xticks(np.concatenate(xticks)) ax.set_xticklabels(x_labels) title(ax, "all objects") ax.set_xlabel("threshold") ax.legend( [Line2D([0], [0], color="b", linewidth=1, linestyle="none", marker=m, c="g") for m in markers], ["all", "XS", "S", "R"], loc="upper right") # plot small objects ax = axs[2, 0] xs = np.arange(4) ys = np.array([stats[:, :-1, 0, 1].mean(), stats[:, :-1, 1, 1].mean(), stats[:, :-1, 2, 1].mean(), stats[:, :-1, 3, 1].mean()]) ys_2 = np.array([stats_2[:, :-1, 0, 1].mean(), stats_2[:, :-1, 1, 1].mean(), stats_2[:, :-1, 2, 1].mean(), stats_2[:, :-1, 3, 1].mean()]) # scatter_with_markers(ax, xs, ys, markers, c='g') scatter_with_markers(ax, xs, ys_2, markers, c='g') # ax.plot(xs, ys, c="g", linestyle="dotted") ax.plot(xs, ys_2, c="black", linestyle="dotted") ax.set_xticks(xs) title(ax, "small objects") ax.set_ylabel("mAR-COCO+") ax.set_xlabel("slenderness") ax.set_xticklabels(["all", "XS", "S", "R"]) # plot medium objects ax = axs[2, 1] xs = np.arange(4) ys = np.array([stats[:, :-1, 0, 2].mean(), stats[:, :-1, 1, 2].mean(), stats[:, :-1, 2, 2].mean(), stats[:, :-1, 3, 2].mean()]) ys_2 = np.array([stats_2[:, :-1, 0, 2].mean(), stats_2[:, :-1, 1, 2].mean(), stats_2[:, :-1, 2, 2].mean(), stats_2[:, :-1, 3, 2].mean()]) # scatter_with_markers(ax, xs, ys, markers, c='g') scatter_with_markers(ax, xs, ys_2, markers, c='g') # ax.plot(xs, ys, c="g", linestyle="dotted") ax.plot(xs, ys_2, c="black", linestyle="dotted") ax.set_xticks(xs) title(ax, "medium objects") ax.set_xlabel("slenderness") ax.set_xticklabels(["all", "XS", "S", "R"]) # plot large objects ax = axs[2, 2] xs = np.arange(4) ys = np.array([stats[:, :-1, 0, 3].mean(), stats[:, :-1, 1, 3].mean(), stats[:, :-1, 2, 3].mean(), stats[:, :-1, 3, 3].mean()]) ys_2 = np.array([stats_2[:, :-1, 0, 3].mean(), stats_2[:, :-1, 1, 3].mean(), stats_2[:, :-1, 2, 3].mean(), stats_2[:, :-1, 3, 3].mean()]) # scatter_with_markers(ax, xs, ys, markers, c='g') scatter_with_markers(ax, xs, ys_2, markers, c='g') # ax.plot(xs, ys, c="g", linestyle="dotted") ax.plot(xs, ys_2, c="black", linestyle="dotted") ax.set_xticks(xs) title(ax, "large objects") ax.set_xlabel("slenderness") ax.set_xticklabels(["all", "XS", "S", "R"]) group = fig2image(fig) webcv2.imshow("group", group) webcv2.waitKey()
def save(mask: np.ndarray, *file_names): assert len(file_names) > 0 save_path = smart_path(os.path.join(file_names[0], *file_names[1:])) with save_path.open('wb') as writer: writer.write(mask.tostring())
queue.put(("sizes", sizes.tostring(), file_name)) else: save(borders, cfg.MASK_DIRECTORY, split_name, "borders", file_name) save(centers, cfg.MASK_DIRECTORY, split_name, "centers", file_name) save(sizes, cfg.MASK_DIRECTORY, split_name, "sizes", file_name) if __name__ == '__main__': args = parse_args() assert not args.show or args.processes < 1 logger = setup_logger() logger.info("Arguments: " + str(args)) cfg = setup(args) dirname = args.output_dir output_dir = smart_path(dirname) if not output_dir.exists(): output_dir.mkdir(exist_ok=True) split_name = getattr(cfg.DATASETS, args.source)[0] metadata = MetadataCatalog.get(split_name) dicts = list(chain.from_iterable([DatasetCatalog.get(k) for k in getattr(cfg.DATASETS, args.source)])) if args.processes > 0: pool = Pool(args.processes) bar = tqdm.tqdm(unit_divisor=len(dicts), maxinterval=len(dicts)) if args.processes > 0: from utils.async_writer import AsyncWriter split_name = "train2017" if "train" in split_name else "val2017"
logger = setup_logger() logger.info("Arguments: " + str(args)) cfg = setup(args) split_name = getattr(cfg.DATASETS, args.source)[0] metadata = MetadataCatalog.get(split_name) dicts = list( chain.from_iterable([ DatasetCatalog.get(k) for k in getattr(cfg.DATASETS, args.source) ])) if args.processes > 0: pool = Pool(args.processes) output_path = smart_path(args.output_file) if output_path.exists(): print(output_path.as_uri, "exists!") import sys sys.exit() with nori2.open(output_path.as_uri(), "w") as writer: for dic in tqdm.tqdm(dicts): if args.image_path is None: file_path = smart_path(dic["file_name"]) else: file_path = smart_path(args.image_path).joinpath( smart_path(dic["file_name"]).name) with file_path.open("rb") as reader: writer.put(reader.read(), filename=file_path.name)