def __init__(self, root=None, image_loader=jpeg4py_loader, data_fraction=None, split="train", version="2014"):
"""
args:
root - path to the coco dataset.
image_loader (default_image_loader) - The function to read the images. If installed,
jpeg4py (https://github.com/ajkxyz/jpeg4py) is used by default. Else,
opencv's imread is used.
data_fraction (None) - Fraction of images to be used. The images are selected randomly. If None, all the
images will be used
split - 'train' or 'val'.
version - version of coco dataset (2014 or 2017)
"""
root = env_settings().coco_dir if root is None else root
super().__init__('COCO_lmdb', root, image_loader)
self.root = root
self.img_pth = 'images/{}{}/'.format(split, version)
self.anno_path = 'annotations/instances_{}{}.json'.format(split, version)
# Load the COCO set.
print('loading annotations into memory...')
tic = time.time()
coco_json = decode_json(root, self.anno_path)
print('Done (t={:0.2f}s)'.format(time.time() - tic))
self.coco_set = COCO(coco_json)
self.cats = self.coco_set.cats
self.class_list = self.get_class_list()
self.sequence_list = self._get_sequence_list()
if data_fraction is not None:
self.sequence_list = random.sample(self.sequence_list, int(len(self.sequence_list)*data_fraction))
self.seq_per_class = self._build_seq_per_class()
def __init__(self,
root=None,
image_loader=jpeg4py_loader,
min_length=0,
max_target_area=1):
"""
args:
root - path to the imagenet vid dataset.
image_loader (default_image_loader) - The function to read the images. If installed,
jpeg4py (https://github.com/ajkxyz/jpeg4py) is used by default. Else,
opencv's imread is used.
min_length - Minimum allowed sequence length.
max_target_area - max allowed ratio between target area and image area. Can be used to filter out targets
which cover complete image.
"""
root = env_settings().imagenet_dir if root is None else root
super().__init__("imagenetvid_lmdb", root, image_loader)
sequence_list_dict = decode_json(root, "cache.json")
self.sequence_list = sequence_list_dict
# Filter the sequences based on min_length and max_target_area in the first frame
self.sequence_list = [
x for x in self.sequence_list if len(x['anno']) >= min_length
and get_target_to_image_ratio(x) < max_target_area
]
def __init__(self,
root=None,
image_loader=jpeg4py_loader,
vid_ids=None,
split=None,
data_fraction=None):
"""
args:
root - path to the lasot dataset.
image_loader (jpeg4py_loader) - The function to read the images. jpeg4py (https://github.com/ajkxyz/jpeg4py)
is used by default.
vid_ids - List containing the ids of the videos (1 - 20) used for training. If vid_ids = [1, 3, 5], then the
videos with subscripts -1, -3, and -5 from each class will be used for training.
split - If split='train', the official train split (protocol-II) is used for training. Note: Only one of
vid_ids or split option can be used at a time.
data_fraction - Fraction of dataset to be used. The complete dataset is used by default
"""
root = env_settings().lasot_dir if root is None else root
super().__init__('LaSOT', root, image_loader)
# Keep a list of all classes
self.class_list = [f for f in os.listdir(self.root)]
self.class_to_id = {
cls_name: cls_id
for cls_id, cls_name in enumerate(self.class_list)
}
self.sequence_list = self._build_sequence_list(vid_ids, split)
if data_fraction is not None:
self.sequence_list = random.sample(
self.sequence_list,
int(len(self.sequence_list) * data_fraction))
self.seq_per_class = self._build_class_list()
def __init__(self, root=None, image_loader=jpeg4py_loader, split=None, seq_ids=None, data_fraction=None):
"""
args:
root - path to the got-10k training data. Note: This should point to the 'train' folder inside GOT-10k
image_loader (jpeg4py_loader) - The function to read the images. jpeg4py (https://github.com/ajkxyz/jpeg4py)
is used by default.
split - 'train' or 'val'. Note: The validation split here is a subset of the official got-10k train split,
not NOT the official got-10k validation split. To use the official validation split, provide that as
the root folder instead.
seq_ids - List containing the ids of the videos to be used for training. Note: Only one of 'split' or 'seq_ids'
options can be used at the same time.
data_fraction - Fraction of dataset to be used. The complete dataset is used by default
"""
root = env_settings().got10k_dir if root is None else root
super().__init__('GOT10k', root, image_loader)
# all folders inside the root
self.sequence_list = self._get_sequence_list()
# seq_id is the index of the folder inside the got10k root path
if split is not None:
if seq_ids is not None:
raise ValueError('Cannot set both split_name and seq_ids.')
ltr_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..')
if split == 'train':
file_path = os.path.join(ltr_path, 'data_specs', 'got10k_train_split.txt')
elif split == 'val':
file_path = os.path.join(ltr_path, 'data_specs', 'got10k_val_split.txt')
elif split == 'train_full':
file_path = os.path.join(ltr_path, 'data_specs', 'got10k_train_full_split.txt')
elif split == 'vottrain':
file_path = os.path.join(ltr_path, 'data_specs', 'got10k_vot_train_split.txt')
elif split == 'votval':
file_path = os.path.join(ltr_path, 'data_specs', 'got10k_vot_val_split.txt')
else:
raise ValueError('Unknown split name.')
seq_ids = pandas.read_csv(file_path, header=None, squeeze=True, dtype=np.int64).values.tolist()
elif seq_ids is None:
seq_ids = list(range(0, len(self.sequence_list)))
self.sequence_list = [self.sequence_list[i] for i in seq_ids]
if data_fraction is not None:
self.sequence_list = random.sample(self.sequence_list, int(len(self.sequence_list)*data_fraction))
self.sequence_meta_info = self._load_meta_info()
self.seq_per_class = self._build_seq_per_class()
self.class_list = list(self.seq_per_class.keys())
self.class_list.sort()
def __init__(self,
root=None,
image_loader=jpeg4py_loader,
data_fraction=None,
min_area=None,
split="train",
version="2014"):
"""
args:
root - path to coco root folder
image_loader (jpeg4py_loader) - The function to read the images. jpeg4py (https://github.com/ajkxyz/jpeg4py)
is used by default.
data_fraction - Fraction of dataset to be used. The complete dataset is used by default
min_area - Objects with area less than min_area are filtered out. Default is 0.0
split - 'train' or 'val'.
version - version of coco dataset (2014 or 2017)
"""
root = env_settings().coco_dir if root is None else root
super().__init__('COCO', root, image_loader)
self.img_pth = os.path.join(root,
'images/{}{}/'.format(split, version))
self.anno_path = os.path.join(
root, 'annotations/instances_{}{}.json'.format(split, version))
self.coco_set = COCO(self.anno_path)
self.cats = self.coco_set.cats
self.class_list = self.get_class_list(
) # the parent class thing would happen in the sampler
self.image_list = self._get_image_list(min_area=min_area)
if data_fraction is not None:
self.image_list = random.sample(
self.image_list, int(len(self.image_list) * data_fraction))
self.im_per_class = self._build_im_per_class()
def __init__(self,
root=None,
image_loader=jpeg4py_loader,
min_length=0,
max_target_area=1):
"""
args:
root - path to the imagenet vid dataset.
image_loader (default_image_loader) - The function to read the images. If installed,
jpeg4py (https://github.com/ajkxyz/jpeg4py) is used by default. Else,
opencv's imread is used.
min_length - Minimum allowed sequence length.
max_target_area - max allowed ratio between target area and image area. Can be used to filter out targets
which cover complete image.
"""
root = env_settings().imagenet_dir if root is None else root
super().__init__("imagenetvid", root, image_loader)
cache_file = os.path.join(root, 'cache.json')
if os.path.isfile(cache_file):
# If available, load the pre-processed cache file containing meta-info for each sequence
with open(cache_file, 'r') as f:
sequence_list_dict = json.load(f)
self.sequence_list = sequence_list_dict
else:
# Else process the imagenet annotations and generate the cache file
self.sequence_list = self._process_anno(root)
with open(cache_file, 'w') as f:
json.dump(self.sequence_list, f)
# Filter the sequences based on min_length and max_target_area in the first frame
self.sequence_list = [
x for x in self.sequence_list if len(x['anno']) >= min_length
and get_target_to_image_ratio(x) < max_target_area
]
def __init__(self,
root=None,
image_loader=jpeg4py_loader,
set_ids=None,
data_fraction=None):
"""
args:
root - The path to the TrackingNet folder, containing the training sets.
image_loader (jpeg4py_loader) - The function to read the images. jpeg4py (https://github.com/ajkxyz/jpeg4py)
is used by default.
set_ids (None) - List containing the ids of the TrackingNet sets to be used for training. If None, all the
sets (0 - 11) will be used.
data_fraction - Fraction of dataset to be used. The complete dataset is used by default
"""
root = env_settings().trackingnet_dir if root is None else root
super().__init__('TrackingNet', root, image_loader)
if set_ids is None:
set_ids = [i for i in range(12)]
self.set_ids = set_ids
# Keep a list of all videos. Sequence list is a list of tuples (set_id, video_name) containing the set_id and
# video_name for each sequence
self.sequence_list = list_sequences(self.root, self.set_ids)
if data_fraction is not None:
self.sequence_list = random.sample(
self.sequence_list,
int(len(self.sequence_list) * data_fraction))
self.seq_to_class_map, self.seq_per_class = self._load_class_info()
# we do not have the class_lists for the tracking net
self.class_list = list(self.seq_per_class.keys())
self.class_list.sort()
