Datasets:
ArXiv:
License:
| """ | |
| trainvalsplit.py is a script that splits an MS COCO formatted dataset into train and val | |
| partitions. For sample usage, run from command line: | |
| Example: | |
| python trainvalsplit.py --help | |
| """ | |
| # Standard Library imports: | |
| import argparse | |
| import sys | |
| import subprocess | |
| from pathlib import Path | |
| # h4dlib imports: | |
| # import _import_helper # pylint: disable=unused-import # noqa: F401 | |
| # PROJ_ROOT = subprocess.check_output(["git", "rev-parse", "--show-toplevel"]).strip().decode("utf-8") | |
| try: | |
| PROJ_ROOT = subprocess.check_output(["git", "rev-parse", "--show-toplevel"]).strip().decode("utf-8") | |
| except subprocess.CalledProcessError: | |
| print("Error: Not inside a Git repository.") | |
| PROJ_ROOT = None | |
| print("PROJ ROOOOOOT: ", PROJ_ROOT) | |
| h4dlib_path = (Path(PROJ_ROOT) / "src/utilities/h4dlib").resolve() | |
| print(h4dlib_path) | |
| assert h4dlib_path.exists() | |
| if str(h4dlib_path) not in sys.path: | |
| sys.path.append(str(h4dlib_path)) | |
| from h4dlib.data.cocohelpers import CocoClassDistHelper, CocoJsonBuilder, split | |
| # Used to check the results of the split--all classes in both splits | |
| # should have at least this many annotations: | |
| _CLASS_COUNT_THRESHOLD = 0 | |
| def create_split( | |
| input_json: Path, | |
| output_path: Path, | |
| output_json_name: str, | |
| seed: int, | |
| test_size: float = 0.2, | |
| ) -> CocoClassDistHelper: | |
| """ | |
| Creates train/val split for the coco-formatted dataset defined by input_json. | |
| params: | |
| input_json: full path or Path object to coco-formatted input json file. | |
| output_path: full path or Path object to directory where outputted json will be | |
| saved. output_json_name: | |
| """ | |
| coco = CocoClassDistHelper(input_json) | |
| train_img_ids, val_img_ids = split( | |
| coco.img_ids, test_size=test_size, random_state=seed | |
| ) | |
| train_counts, train_percents = coco.get_class_dist(train_img_ids) | |
| val_counts, val_percents = coco.get_class_dist(val_img_ids) | |
| # Generate coco-formatted json's for train and val: | |
| def generate_coco_json(coco, split_type, img_ids): | |
| coco_builder = CocoJsonBuilder( | |
| coco.cats, | |
| dest_path=output_path, | |
| dest_name=output_json_name.format(split_type), | |
| ) | |
| for idx, img_id in enumerate(img_ids): | |
| coco_builder.add_image(coco.imgs[img_id], coco.imgToAnns[img_id]) | |
| coco_builder.save() | |
| generate_coco_json(coco, "train", train_img_ids) | |
| generate_coco_json(coco, "val", val_img_ids) | |
| return coco | |
| def verify_output( | |
| original_coco: CocoClassDistHelper, output_path: Path, output_json_name: str | |
| ) -> None: | |
| """ | |
| Verify that the outputted json's for the train/val split can be loaded, and | |
| have correct number of annotations, and minimum count for each class meets | |
| our threshold. | |
| """ | |
| def verify_split_part(output_json_name, split_part): | |
| json_path = output_path / output_json_name.format(split_part) | |
| print(f"Checking if we can load json via coco api:{json_path}...") | |
| coco = CocoClassDistHelper(json_path) | |
| counts, _ = coco.get_class_dist() | |
| assert min(counts.values()) >= _CLASS_COUNT_THRESHOLD, ( | |
| f"min class count ({min(counts.values())}) is " | |
| + f"lower than threshold of {_CLASS_COUNT_THRESHOLD}" | |
| ) | |
| print(f"{split_part} class counts: ", counts) | |
| return coco | |
| train_coco = verify_split_part(output_json_name, "train") | |
| val_coco = verify_split_part(output_json_name, "val") | |
| assert len(original_coco.imgs) == len(train_coco.imgs) + len( | |
| val_coco.imgs | |
| ), "Num Images in original data should equal sum of imgs in splits." | |
| assert len(original_coco.anns) == len(train_coco.anns) + len( | |
| val_coco.anns | |
| ), "Num annotations in original data should equal sum of those in splits." | |
| def main(args: argparse.Namespace): | |
| """ | |
| Creates train/val split and verifies output. | |
| params: | |
| opt: command line options (there are none right now) | |
| output_json_name: format-string of output file names, with a '{}' | |
| style placeholder where split type will be inserted. | |
| """ | |
| input_json = Path(args.input_json).resolve() | |
| assert input_json.exists(), str(input_json) | |
| assert input_json.is_file(), str(input_json) | |
| output_path = Path(args.output_dir).resolve() | |
| assert output_path.is_dir(), str(output_path) | |
| output_path.mkdir(exist_ok=True, parents=True) | |
| output_json_name = input_json.stem.replace("_full", "") + "_{}.json" | |
| original_coco = create_split( | |
| input_json, output_path, output_json_name, args.seed, args.val_split_size | |
| ) | |
| verify_output(original_coco, output_path, output_json_name) | |
| if __name__ == "__main__": | |
| parser = argparse.ArgumentParser() | |
| parser.add_argument("--val_split_size", type=float, default=0.2) | |
| parser.add_argument( | |
| "--seed", | |
| type=int, | |
| help="Random seed. Use split_search.py to find a seed that generates a good split", | |
| ) | |
| parser.add_argument("--input_json", type=Path, help="Input json path") | |
| parser.add_argument("--output_dir", type=Path, help="Path to output json") | |
| args = parser.parse_args() | |
| main(args) | |