def __init__(self, engine): super().__init__(engine, extraction_keys=DETECTION_EXTRACTION_KEYS + (Extractions.REID_FEATURES, )) self.add_masks = self.config.bool("add_masks", True) self.export_embeddings = self.config.bool("export_embeddings", False) tracker_reid_comp = self.config.string("tracker_reid_comp", "sigmoid_dot") tracker = self.config.string("tracker", "greedy") detection_confidence_threshold_car = self.config.float( "detection_confidence_threshold_car", 0.55) detection_confidence_threshold_pedestrian = self.config.float( "detection_confidence_threshold_pedestrian", 0.95) reid_weight_car = self.config.float("reid_weight_car", 1.0) reid_weight_pedestrian = self.config.float("reid_weight_pedestrian", 1.0) mask_iou_weight_car = self.config.float("mask_iou_weight_car", 0.0) mask_iou_weight_pedestrian = self.config.float( "mask_iou_weight_pedestrian", 0.0) bbox_center_weight_car = self.config.float("bbox_center_weight_car", 0.0) bbox_center_weight_pedestrian = self.config.float( "bbox_center_weight_pedestrian", 0.0) bbox_iou_weight_car = self.config.float("bbox_iou_weight_car", 0.0) bbox_iou_weight_pedestrian = self.config.float( "bbox_iou_weight_pedestrian", 0.0) association_threshold_car = self.config.float( "association_threshold_car", 0.3) association_threshold_pedestrian = self.config.float( "association_threshold_pedestrian", 0.3) keep_alive_car = self.config.int("keep_alive_car", 0) keep_alive_pedestrian = self.config.int("keep_alive_pedestrian", 0) reid_euclidean_offset_car = self.config.float( "reid_euclidean_offset_car", 5.0) reid_euclidean_scale_car = self.config.float( "reid_euclidean_scale_car", 1.0) reid_euclidean_offset_pedestrian = self.config.float( "reid_euclidean_offset_pedestrian", 5.0) reid_euclidean_scale_pedestrian = self.config.float( "reid_euclidean_scale_pedestrian", 1.0) box_offset = self.config.float("box_offset", 50.0) box_scale = self.config.float("box_scale", 0.02) new_reid = self.config.bool("new_reid", False) new_reid_threshold_car = self.config.float("new_reid_threshold_car", 2.0) new_reid_threshold_pedestrian = self.config.float( "new_reid_threshold_pedestrian", 2.0) self.tracker_options = { "tracker": tracker, "reid_comp": tracker_reid_comp, "detection_confidence_threshold_car": detection_confidence_threshold_car, "detection_confidence_threshold_pedestrian": detection_confidence_threshold_pedestrian, "reid_weight_car": reid_weight_car, "reid_weight_pedestrian": reid_weight_pedestrian, "mask_iou_weight_car": mask_iou_weight_car, "mask_iou_weight_pedestrian": mask_iou_weight_pedestrian, "bbox_center_weight_car": bbox_center_weight_car, "bbox_center_weight_pedestrian": bbox_center_weight_pedestrian, "bbox_iou_weight_car": bbox_iou_weight_car, "bbox_iou_weight_pedestrian": bbox_iou_weight_pedestrian, "association_threshold_car": association_threshold_car, "association_threshold_pedestrian": association_threshold_pedestrian, "keep_alive_car": keep_alive_car, "keep_alive_pedestrian": keep_alive_pedestrian, "reid_euclidean_offset_car": reid_euclidean_offset_car, "reid_euclidean_scale_car": reid_euclidean_scale_car, "reid_euclidean_offset_pedestrian": reid_euclidean_offset_pedestrian, "reid_euclidean_scale_pedestrian": reid_euclidean_scale_pedestrian, "new_reid_threshold_car": new_reid_threshold_car, "new_reid_threshold_pedestrian": new_reid_threshold_pedestrian, "box_offset": box_offset, "box_scale": box_scale, "new_reid": new_reid } self.mask_disjoint_strategy = self.config.string( "mask_disjoint_strategy", "y_pos") # Or "score" self.export_detections = self.config.bool("export_detections", False) self.import_detections = self.config.bool("import_detections", False) self.visualize_tracks = self.config.bool("visualize_tracks", False) self.do_tracking = self.config.bool("do_tracking", True) self.embeddings = {} self.optical_flow_path = self.config.string( "optical_flow_path", "/work/" + username() + "/data/KITTI_flow_pwc/") self.run_tracking_eval = self.config.bool("run_tracking_eval", False)
from datasets.Loader import register_dataset from datasets.Mapillary.MapillaryLike_instance import MapillaryLikeInstanceDataset from datasets.util.Util import username DEFAULT_PATH = "/fastwork/" + username() + "/mywork/data/mapillary/" NAME = "mapillary_instance" @register_dataset("mapillary_instance_full", resolution="full") @register_dataset("mapillary_instance_half", resolution="half") @register_dataset("mapillary_instance_quarter", resolution="quarter") class MapillaryInstanceDataset(MapillaryLikeInstanceDataset): def __init__(self, config, subset, resolution): assert resolution in ("quarter", "half", "full"), resolution if resolution == "full": default_path = DEFAULT_PATH else: default_path = DEFAULT_PATH.replace( "/mapillary/", "/mapillary_{}/".format(resolution)) # there are 37 classes with instances in total # we excluded the following: # 8: construction--flat--crosswalk-plain -> doesn't really look like a useful object category # 34: object--bike-rack -> holes* # 45: object--support--pole -> very large and thin -> bounding box does not capture it well # 46: object--support--traffic-sign-frame -> holes* # 47: object--support--utility-pole -> holes* # further candidate for exclusion: # 0: animal--bird -> usually very small
import tensorflow as tf import numpy as np from datasets import DataKeys from datasets.Mapillary.MapillaryLike_instance import MapillaryLikeInstanceDataset from datasets.util.TrackingGT import load_tracking_gt_KITTI from datasets.KITTI.segtrack.KITTI_segtrack import DEFAULT_PATH from datasets.Loader import register_dataset from datasets.util.Util import username NAME = "KITTI_segtrack_bbox_regression" KITTI_TRACKING_GT_DEFAULT_PATH = "/home/" + username( ) + "/vision/mask_annotations/KITTI_tracking_annotations/" @register_dataset(NAME) class KittiSegtrackBboxRegressionDataset(MapillaryLikeInstanceDataset): def __init__(self, config, subset): super().__init__(config, subset, NAME, DEFAULT_PATH, "datasets/KITTI/segtrack/", 1000, [1, 2]) self._gt = load_tracking_gt_KITTI(KITTI_TRACKING_GT_DEFAULT_PATH, filter_to_cars_and_pedestrians=True) def postproc_annotation(self, ann_filename, ann): ann = super().postproc_annotation(ann_filename, ann) if not isinstance(ann, dict): ann = {DataKeys.SEGMENTATION_LABELS: ann} def _lookup_bbox(fn): fn = fn.decode("utf-8") sp = fn.split(":")
import glob import tensorflow as tf from datasets.DetectionDataset import MapillaryLikeDetectionFileListDataset from datasets.KITTI.segtrack.KITTI_MOTS_info import SEQ_IDS_TRAIN, SEQ_IDS_VAL from datasets.Loader import register_dataset from datasets.util.Util import username from datasets import DataKeys from shutil import copytree from random import randint from core.Log import log import os NAME = "KITTI_segtrack" NAME_DETECTION = "KITTI_segtrack_detection" DEFAULT_PATH = "/globalwork/" + username() + "/data/KITTI_MOTS/train/" ID_DIVISOR = 1000 CLASS_IDS_WITH_INSTANCES = [1, 2] CROWD_ID = 10 NUM_CLASSES = 3 # background, car, pedestrian N_MAX_DETECTIONS = 100 # used for detection on individual images @register_dataset(NAME_DETECTION) class KittiSegtrackDetectionDataset(MapillaryLikeDetectionFileListDataset): def __init__(self, config, subset, name=NAME, default_path=DEFAULT_PATH): self.seq_ids_train = SEQ_IDS_TRAIN self.seq_ids_val = SEQ_IDS_VAL self.imgs_are_pngs = config.bool("imgs_are_pngs", True) t = config.string_list("seq_ids_train", [])
import numpy as np from datasets.MOT.MOT_common import MOTDetectionDataset, MOTDataset from datasets.Loader import register_dataset from datasets.util.Util import username # MOT17 is the same sequences as MOT16 with better ground truth annotations NAME = "MOT17" NAME_DETECTION = "MOT17_detection" DEFAULT_PATH = "/fastwork/" + username() + "/mywork/data/MOT17/" NUM_CLASSES = 3 # background, car, pedestrian N_MAX_DETECTIONS = 100 # TODO This is from savitar1, any papers we can take this split from? SEQ_IDS_TRAIN = ["MOT17-%02d-DPM" % idx for idx in [2, 5, 10, 13]] SEQ_IDS_VAL = ["MOT17-%02d-DPM" % idx for idx in [4, 9, 11]] # used for detection on invididual images @register_dataset(NAME_DETECTION) class MOT17DetectionDataset(MOTDetectionDataset): def __init__(self, config, subset): super().__init__(config, subset, NAME, DEFAULT_PATH, SEQ_IDS_TRAIN, SEQ_IDS_VAL, NUM_CLASSES) def get_data_arrays_for_file(self, img_filename, img_h, img_w): return mot17_get_data_arrays_for_file(self.gt_data, self.cat_to_class, self.visibility_threshold, img_filename, img_h, img_w) # used for training on chunks of video @register_dataset(NAME)
import glob from datasets.Dataset import FileListDataset from datasets.Loader import register_dataset from datasets.util.Util import username NAME = "kitti_mturkers_instance" DEFAULT_PATH = "/fastwork/" + username() + "/mywork/data/KITTI/" @register_dataset(NAME) class KITTIMturkersInstanceDataset(FileListDataset): def __init__(self, config, subset, name=NAME): super(KITTIMturkersInstanceDataset, self).__init__(config, name, subset, DEFAULT_PATH, 2) def read_inputfile_lists(self): files = glob.glob(self.data_dir + "object/segmentations_jay_per_instance_new/*.png") imgs = [ self.data_dir + "object/image_2/" + file.split("/")[-1].split(":")[0] + ".png" for file in files ] return imgs, files
import glob import tensorflow as tf from datasets.Dataset import FileListDataset from datasets.Loader import register_dataset from datasets.util.Util import username NAME = "grabcut" DEFAULT_PATH="/fastwork/" + username() + "/mywork/data/Grabcut/" @register_dataset(NAME) class GrabcutDataset(FileListDataset): def __init__(self, config, subset, name=NAME): super().__init__(config, dataset_name=name, subset=subset, default_path=DEFAULT_PATH, num_classes=2) def postproc_annotation(self, ann_filename, ann): ann_postproc = tf.where(tf.equal(ann, 255), tf.ones_like(ann), ann) ann_postproc = tf.where(tf.equal(ann_postproc, 128), tf.ones_like(ann) * 255, ann_postproc) return ann_postproc def read_inputfile_lists(self): img_dir = self.data_dir + "images/" gt_dir = self.data_dir + "images-gt/" imgs = [] gts = [] for filename in glob.glob(img_dir + "*"): fn_base = filename.split("/")[-1].rsplit(".")[0] imgs += [filename] gts += [gt_dir + fn_base + ".png"]
import glob import tensorflow as tf from datasets.Loader import register_dataset from datasets.Dataset import FileListDataset from datasets.util.Util import username NUM_CLASSES = 2 VOID_LABEL = 255 # for translation augmentation DAVIS_DEFAULT_PATH = "/fastwork/" + username() + "/mywork/data/DAVIS/" DAVIS2017_DEFAULT_PATH = "/fastwork/" + username() + "/mywork/data/DAVIS2017/" DAVIS_FLOW_DEFAULT_PATH = "/fastwork/" + username( ) + "/mywork/data/DAVIS_data/" DAVIS_LUCID_DEFAULT_PATH = "/fastwork/" + username( ) + "/mywork/data/DAVIS_data/lucid/" DAVIS2017_LUCID_DEFAULT_PATH = "/fastwork/" + username( ) + "/mywork/data/DAVIS2017_data/lucid/" DAVIS_IMAGE_SIZE = (480, 854) DAVIS2017_IMAGE_SIZE = (480, None) def read_image_and_annotation_list(fn, data_dir): imgs = [] ans = [] with open(fn) as f: for l in f: sp = l.split() an = data_dir + sp[1] im = data_dir + sp[0] imgs.append(im)
import glob import os import numpy as np from datasets.MOT.MOT_common import MOTDetectionDataset, MOTDataset from datasets.Loader import register_dataset from datasets.util.Util import username # MOT17 is the same sequences as MOT16 with better ground truth annotations NAME = "PathTrack" NAME_DETECTION = "PathTrack_detection" DEFAULT_PATH = "/fastwork/" + username( ) + "/data/pathtrack_release_v1.0/pathtrack_release" # PathTrack actually only contains pedestrian annotations; keep the three classes here so that it fits with MOT17 NUM_CLASSES = 3 # background, car, pedestrian N_MAX_DETECTIONS = 100 # TODO Which split? PATHTRACK_SEQUENCES = sorted( glob.glob(os.path.join(DEFAULT_PATH, "train", "*"))) PATHTRACK_SEQUENCES = [seq.split("/")[-1] for seq in PATHTRACK_SEQUENCES] PATHTRACK_SPLITPOINT = int(np.ceil(len(PATHTRACK_SEQUENCES) * 0.7)) SEQ_IDS_TRAIN = PATHTRACK_SEQUENCES[:PATHTRACK_SPLITPOINT] SEQ_IDS_VAL = PATHTRACK_SEQUENCES[PATHTRACK_SPLITPOINT:] # used for detection on invididual images @register_dataset(NAME_DETECTION) class PathTrackDetectionDataset(MOTDetectionDataset): def __init__(self, config, subset): super().__init__(config, subset, NAME, DEFAULT_PATH, SEQ_IDS_TRAIN,
from datasets.Loader import register_dataset from datasets.Mapillary.MapillaryLike_instance import MapillaryLikeInstanceDataset from datasets.util.Util import username DEFAULT_PATH = "/home/" + username() + "/data/KITTI_instance/" NAME = "KITTI_instance" @register_dataset(NAME) class KittiInstanceDataset(MapillaryLikeInstanceDataset): def __init__(self, config, subset): super().__init__(config, subset, NAME, DEFAULT_PATH, "datasets/KITTI/official", 256, cat_ids_to_use=list(range(24, 34)))
import numpy as np from datasets.MOT.MOT_common import MOTDetectionDataset, MOTDataset from datasets.Loader import register_dataset from datasets.util.Util import username NAME = "2DMOT2015" NAME_DETECTION = "2DMOT2015_detection" DEFAULT_PATH = "/fastwork/" + username() + "/mywork/data/2DMOT2015/" # MOT2015 actually only contains pedestrian annotations; keep the three classes here so that it fits with MOT17 NUM_CLASSES = 3 # background, car, pedestrian N_MAX_DETECTIONS = 100 # This is from savitar1, I think this split appears in some Paper #SEQ_IDS_TRAIN = ["TUD-Stadtmitte", "ETH-Bahnhof", "ADL-Rundle-6", "KITTI-13", "PETS09-S2L1"] #SEQ_IDS_VAL = ["TUD-Campus", "ETH-Sunnyday", "ETH-Pedcross2", "ADL-Rundle-8", "Venice-2", "KITTI-17"] # This is all from 2DMOT2015 train which is not in either KITTI or MOT17 SEQ_IDS_TRAIN = ["TUD-Stadtmitte", "ETH-Bahnhof", "PETS09-S2L1"] SEQ_IDS_VAL = ["TUD-Campus", "ETH-Sunnyday", "Venice-2"] # used for detection on invididual images @register_dataset(NAME_DETECTION) class MOT15DetectionDataset(MOTDetectionDataset): def __init__(self, config, subset): super().__init__(config, subset, NAME, DEFAULT_PATH, SEQ_IDS_TRAIN, SEQ_IDS_VAL, NUM_CLASSES) def get_data_arrays_for_file(self, img_filename, img_h, img_w): return mot15_get_data_arrays_for_file(self.gt_data, img_filename, img_h, img_w)