def __init__(
self,
root,
split="training",
is_transform=False,
img_size=512,
augmentations=None,
img_norm=True,
):
self.root = root
self.split = split
self.is_transform = is_transform
self.augmentations = augmentations
self.img_norm = img_norm
self.n_classes = 100
self.img_size = (img_size if isinstance(img_size, tuple) else
(img_size, img_size))
self.mean = np.array([104.00699, 116.66877, 122.67892])
self.files = collections.defaultdict(list)
for split in ["training", "Masks"]:
print(os.path.exists(self.root + split))
if (split == "training"):
file_list = recursive_glob(rootdir=self.root + split,
suffix=".jpg")
self.files[split] = file_list
else:
file_list = recursive_glob(rootdir=self.root + split,
suffix=".png")
self.files[split] = file_list
def __init__(
self,
root,
split="training",
is_transform=False,
img_size=(480, 640),
augmentations=None,
img_norm=True,
):
self.root = root
self.is_transform = is_transform
self.n_classes = 38
self.augmentations = augmentations
self.img_norm = img_norm
self.img_size = img_size if isinstance(img_size, tuple) else (img_size, img_size)
self.mean = np.array([104.00699, 116.66877, 122.67892])
self.files = collections.defaultdict(list)
self.anno_files = collections.defaultdict(list)
self.cmap = self.color_map(normalized=False)
split_map = {"training": "train", "val": "test"}
self.split = split_map[split]
for split in ["train", "test"]:
file_list = sorted(recursive_glob(rootdir=self.root + split + "/", suffix="jpg"))
self.files[split] = file_list
for split in ["train", "test"]:
file_list = sorted(
recursive_glob(rootdir=self.root + "annotations/" + split + "/", suffix="png")
)
self.anno_files[split] = file_list
def __init__(self,
root,
split="training",
is_transform=False,
img_size=512,
augmentations=None,
img_norm=True,
test_mode=False,
n_classes=151,
fold=None):
self.root = root
self.split = split
self.is_transform = is_transform
self.augmentations = augmentations
self.img_norm = img_norm
self.test_mode = test_mode
self.n_classes = n_classes
self.fold = fold
ignore_dict = {0: [91, 128, 127, 77, 99], 1: [], 2: [], 3: []}
self.ignore_classes = ignore_dict[self.fold]
self.img_size = img_size if isinstance(img_size, list) else (img_size,
img_size)
self.mean = np.array([104.00699, 116.66877, 122.67892])
self.files = collections.defaultdict(list)
self.class_names = self.parse_classes(self.root + 'classes.txt')
if not self.test_mode:
for split in ["training", "validation"]:
file_list = recursive_glob(rootdir=self.root + "images/" +
self.split + "/",
suffix=".jpg")
self.files[split] = file_list
def __init__(self,
root,
split="training",
img_size=(640, 1280),
is_transform=True,
augmentations=None):
self.root = root
self.split = split
self.is_transform = is_transform
self.augmentations = augmentations
self.n_classes = 65
self.img_size = img_size if isinstance(img_size, tuple) else (img_size,
img_size)
self.mean = np.array([80.5423, 91.3162, 81.4312])
self.files = {}
self.images_base = os.path.join(self.root, self.split, "images")
self.annotations_base = os.path.join(self.root, self.split, "labels")
self.files[split] = recursive_glob(rootdir=self.images_base,
suffix=".jpg")
self.class_ids, self.class_names, self.class_colors = self.parse_config(
)
self.ignore_id = 250
if not self.files[split]:
raise Exception("No files for split=[%s] found in %s" %
(split, self.images_base))
print("Found %d %s images" % (len(self.files[split]), split))
def __init__(self,
root,
split="training",
is_transform=False,
img_size=(480, 640),
augmentations=None):
self.root = root
self.is_transform = is_transform
self.n_classes = 14
self.augmentations = augmentations
self.img_size = img_size if isinstance(img_size, tuple) else (img_size,
img_size)
self.mean = np.array([104.00699, 116.66877, 122.67892])
self.files = collections.defaultdict(list)
self.cmap = self.color_map(normalized=False)
split_map = {
"training": 'train',
"val": 'test',
}
self.split = split_map[split]
for split in ["train", "test"]:
file_list = recursive_glob(rootdir=self.root + split + '/',
suffix='png')
self.files[split] = file_list
def __init__(
self,
root,
split="training",
is_transform=False,
img_size=512,
augmentations=None,
img_norm=True,
):
self.root = root
self.is_transform = is_transform
self.augmentations = augmentations
self.img_norm = img_norm
self.n_classes = 150
self.img_size = (img_size if isinstance(img_size, tuple) else
(img_size, img_size))
self.mean = np.array([104.00699, 116.66877, 122.67892])
self.files = collections.defaultdict(list)
split_map = {"training": "training", "val": "validation"}
self.split = split_map[split]
for split in ["training", "validation"]:
file_list = recursive_glob(rootdir=self.root + "images/" + split +
"/",
suffix=".jpg")
self.files[split] = file_list
def __init__(self, root, split="training", is_transform=False, img_size=512):
"""__init__
:param root:
:param split:
:param is_transform:
:param img_size:
"""
self.root = root
self.split = split
self.is_transform = is_transform
self.n_classes = 151 # 0 is reserved for "other"
self.img_size = img_size if isinstance(img_size, tuple) else (img_size, img_size)
self.mean = np.array([104.00699, 116.66877, 122.67892])
self.files = {}
self.images_base = os.path.join(self.root, 'images', self.split)
self.annotations_base = os.path.join(self.root, 'annotations', self.split)
self.files[split] = recursive_glob(rootdir=self.images_base, suffix='.jpg')
if not self.files[split]:
raise Exception("No files for split=[%s] found in %s" % (split, self.images_base))
print("Found %d %s images" % (len(self.files[split]), split))
def __init__(self, root, split="test"):
"""__init__
:param root:
:param split:
:param setting:
"""
self.root = root
self.split = split
self.n_classes = 3
self.files = {}
self.images_base = os.path.join(self.root, self.split)
# Generate list of all tif files and save in dictionary
self.files[split] = recursive_glob(rootdir=self.images_base,
suffix="_Img.tif")
self.ignore_index = 250
self.valid_classes = {0: self.ignore_index, 1: 0, 2: 1, 3: 2}
self.class_names = {
self.ignore_index: "Ignore",
0: "Background",
1: "Contour",
2: "Nuclei"
}
if not self.files[split]:
raise Exception("No files for split=[%s] found in %s" %
(split, self.images_base))
print("Found %d %s images" % (len(self.files[split]), split))
## Augmentations ###
self.image_transform = self.get_transform(split == "train")
def __init__(self,
root,
split="training",
is_transform=False,
img_size=512):
"""__init__
:param root:
:param split:
:param is_transform:
:param img_size:
"""
self.root = root
self.split = split
self.is_transform = is_transform
self.n_classes = 151 # 0 is reserved for "other"
self.img_size = img_size if isinstance(img_size, tuple) else (img_size,
img_size)
self.mean = np.array([104.00699, 116.66877, 122.67892])
self.files = {}
self.images_base = os.path.join(self.root, 'images', self.split)
self.annotations_base = os.path.join(self.root, 'annotations',
self.split)
self.files[split] = recursive_glob(rootdir=self.images_base,
suffix='.jpg')
if not self.files[split]:
raise Exception("No files for split=[%s] found in %s" %
(split, self.images_base))
print("Found %d %s images" % (len(self.files[split]), split))
def __init__(self,
root,
split="train",
is_transform=False,
img_size=(1280, 384),
augmentations=None,
version='pascal',
phase='train'):
"""__init__
:param root:
:param split:
:param is_transform: (not used)
:param img_size: (not used)
:param augmentations (not used)
"""
self.root = root
self.split = split
self.is_transform = is_transform
self.augmentations = augmentations
self.n_classes = 2
self.img_size = img_size
self.mean = np.array(self.mean_rgb)
self.files = {}
if phase == 'train':
self.images_base = os.path.join(self.root, 'training', 'image_2')
self.lidar_base = os.path.join(self.root, 'training', 'ADI')
self.annotations_base = os.path.join(self.root, 'training',
'gt_image_2')
self.im_files = recursive_glob(rootdir=self.images_base,
suffix='.png')
else:
self.images_base = os.path.join(self.root, 'testing', 'image_2')
self.lidar_base = os.path.join(self.root, 'testing', 'ADI')
self.annotations_base = os.path.join(self.root, 'testing',
'gt_image_2')
self.split = 'test'
self.im_files = recursive_glob(rootdir=self.images_base,
suffix='.png')
self.im_files = sorted(self.im_files)
self.data_size = len(self.im_files)
self.phase = phase
print("Found %d %s images" % (self.data_size, self.split))
def __init__(self,
root,
split="train",
is_transform=False,
img_size=None,
augmentations=None,
img_norm=True):
"""__init__
:param root:
:param split:
:param is_transform:
:param img_size:
:param augmentations
"""
self.root = root
self.split = split
self.img_size = (
374, 1238
) # img_size if isinstance(img_size, tuple) else (img_size, img_size)
self.is_transform = is_transform
self.augmentations = augmentations
self.img_norm = img_norm
self.mean = np.array([100.00517842, 106.47954702, 103.08725176])
self.n_classes = 19
self.files = {}
self.images_base = os.path.join(self.root, 'data_semantics', 'custom',
self.split, 'image_2')
self.annotations_base = os.path.join(self.root, 'data_semantics',
'custom', self.split, 'semantic')
self.files[split] = recursive_glob(rootdir=self.images_base,
suffix='.png')
self.void_classes = [
0, 1, 2, 3, 4, 5, 6, 9, 10, 14, 15, 16, 18, 29, 30, -1
]
self.valid_classes = [
7, 8, 11, 12, 13, 17, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 31,
32, 33
]
self.class_names = ['unlabelled', 'road', 'sidewalk', 'building', 'wall', 'fence',\
'pole', 'traffic_light', 'traffic_sign', 'vegetation', 'terrain',\
'sky', 'person', 'rider', 'car', 'truck', 'bus', 'train', \
'motorcycle', 'bicycle']
self.ignore_index = 250
self.class_map = dict(zip(self.valid_classes, range(19)))
if not self.files[split]:
raise Exception("No files for split=[%s] found in %s" %
(split, self.images_base))
print("Found %d %s images" % (len(self.files[split]), split))
print("Image Size: {}".format(self.img_size))
def __init__(self,
root,
split="train",
is_transform=False,
img_size=(512, 1024),
augmentations=None,
img_norm=True,
version='pascal'):
"""__init__
:param root:
:param split:
:param is_transform:
:param img_size:
:param augmentations
"""
self.root = root
self.split = split
self.is_transform = is_transform
self.augmentations = augmentations
self.img_norm = img_norm
self.n_classes = 20
self.img_size = img_size if isinstance(img_size, tuple) else (img_size,
img_size)
self.mean = np.array(self.mean_rgb[version])
self.files = {}
self.images_base = os.path.join(self.root, 'leftImg8bit', self.split)
self.annotations_base = os.path.join(self.root, 'gtFine_trainvaltest',
'gtFine', self.split)
self.files[split] = recursive_glob(rootdir=self.images_base,
suffix='.png')
## Revert Back to Original if there is some problem
self.void_classes = [
0, 1, 2, 3, 4, 5, 9, 10, 14, 15, 16, 18, 29, 30, -1
]
self.valid_classes = [
7, 8, 11, 12, 13, 17, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 31,
32, 33, 34
]
self.class_names = ['unlabelled', 'road', 'sidewalk', 'building', 'wall', 'fence',\
'pole', 'traffic_light', 'traffic_sign', 'vegetation', 'terrain',\
'sky', 'person', 'rider', 'car', 'truck', 'bus', 'train', \
'motorcycle', 'bicycle', 'roadLines']
self.ignore_index = 250
self.class_map = dict(zip(self.valid_classes, range(20)))
if not self.files[split]:
raise Exception("No files for split=[%s] found in %s" %
(split, self.images_base))
print("Found %d %s images" % (len(self.files[split]), split))
def __init__(self,
root,
split="train",
is_transform=False,
use_multi_scale=False,
img_size=(600, 800),
augmentations=None,
img_norm=True,
version='pascal',
phase='train',
fpn=False,
norm=False):
"""__init__
:param root:
:param split:
:param is_transform:
:param img_size:
:param augmentations
"""
self.root = root
self.split = split
self.is_transform = is_transform
self.augmentations = augmentations
self.img_norm = img_norm
self.n_classes = 15 #9 #15
self.img_size = img_size if isinstance(img_size, tuple) else (img_size,
img_size)
self.mean = np.array(self.mean_rgb)
self.files = {}
#if phase == 'train':
self.images_base = os.path.join(self.root, 'images')
self.annotations_base = os.path.join(self.root, 'labelsRelabelling')
self.im_files = recursive_glob(rootdir=self.images_base, suffix='.jpg')
self.data_size = len(self.im_files)
self.phase = phase
self.fpn = fpn
self.norm = norm
#import pdb.set_trace()
#self.void_classes = [0, 1, 2, 3, 4, 5, 6, 9, 10, 14, 15, 16, 18, 29, 30, -1]
#self.valid_classes = [7, 8, 11, 12, 13, 17, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 31, 32, 33]
#self.class_names = ['unlabelled', 'road', 'sidewalk', 'building', 'wall', 'fence',\
# 'pole', 'traffic_light', 'traffic_sign', 'vegetation', 'terrain',\
# 'sky', 'person', 'rider', 'car', 'truck', 'bus', 'train', \
# 'motorcycle', 'bicycle']
#self.ignore_index = 250
#self.class_map = dict(zip(self.valid_classes, range(19)))
#if not self.files[split]:
# raise Exception("No files for split=[%s] found in %s" % (split, self.images_base))
print("Found %d %s images" % (self.data_size, split))
def __init__(
self,
root,
split="training",
is_transform=False,
img_size=(480, 640),
augmentations=None,
img_norm=False,
test_mode=False,
):
self.root = root
self.is_transform = is_transform
self.n_classes = 38
self.augmentations = augmentations
self.img_norm = img_norm
self.test_mode = test_mode
self.img_size = img_size if isinstance(img_size, tuple) else (img_size,
img_size)
self.mean = np.array([104.00699, 116.66877, 122.67892])
self.files = collections.defaultdict(list)
self.anno_files = collections.defaultdict(list)
self.cmap = self.color_map(normalized=False)
split_map = {"training": "train", "val": "test"}
self.split = split_map[split]
if not self.test_mode:
self.images_base = os.path.join(self.root, self.split)
self.annotations_base = os.path.join(self.root, "labels",
self.split)
print(self.images_base)
print(self.annotations_base)
# for split in ["train", "test"]:
file_list = sorted(
recursive_glob(rootdir=self.images_base, suffix="jpg"))
self.files[self.split] = file_list
# print(self.files[self.split])
# for split in ["train", "test"]:
file_list = sorted(
recursive_glob(rootdir=self.annotations_base, suffix="png"))
self.anno_files[self.split] = file_list
def __init__(
self,
data_root="",
presentation_root="",
is_transform=False,
img_size=512,
augmentations=None,
aug_k=4,
img_norm=True,
test_mode=False,
):
self.data_root = data_root
self.presentation_root = presentation_root
self.is_transform = is_transform
self.augmentations = augmentations
self.aug_k = aug_k
self.img_norm = img_norm
self.test_mode = test_mode
self.n_classes = 6
self.img_size = img_size if isinstance(img_size, tuple) else (img_size, img_size)
self.mean = np.array([104.00699, 116.66877, 122.67892])
if not self.test_mode:
image_list = recursive_glob(rootdir=self.data_root + "images/training/", suffix=".jpg")
annotation_list = recursive_glob(rootdir=self.data_root + "annotations/training/", suffix='.png')
presentation_list = read_file(rootdir=self.presentation_root, filename='train_presentations.txt', split=',')
classes_list = read_file(rootdir=self.presentation_root, filename="train_class_list.txt", split=',')
else:
image_list = recursive_glob(rootdir=self.data_root + "images/validation/", suffix='.jpg')
annotation_list = recursive_glob(rootdir=self.data_root + "annotations/validation/", suffix='.png')
presentation_list = read_file(rootdir=self.presentation_root, filename='val_presentations.txt', split=',')
classes_list = read_file(rootdir=self.presentation_root, filename='val_class_list.txt', split=',')
self.images = image_list
self.annotations = annotation_list
self.presentations = presentation_list
self.pre_classes = classes_list
self.presentation = []
self.classes = []
self.image_data = []
self.label_data = []
def __init__(self, root, split="training", is_transform=False, img_size=512):
self.root = root
self.split = split
self.is_transform = is_transform
self.n_classes = 150
self.img_size = img_size if isinstance(img_size, tuple) else (img_size, img_size)
self.mean = np.array([104.00699, 116.66877, 122.67892])
self.files = collections.defaultdict(list)
for split in ["training", "validation",]:
file_list = recursive_glob(rootdir=self.root + 'images/' + self.split + '/', suffix='.jpg')
self.files[split] = file_list
def __init__(self, root, split="training", is_transform=False, img_size=(480, 640), augmentations=None):
self.root = root
self.is_transform = is_transform
self.n_classes = 38
self.augmentations = augmentations
self.img_size = img_size if isinstance(img_size, tuple) else (img_size, img_size)
self.mean = np.array([104.00699, 116.66877, 122.67892])
self.files = collections.defaultdict(list)
self.anno_files = collections.defaultdict(list)
self.cmap = self.color_map(normalized=False)
split_map = {"training": 'train',
"val": 'test',}
self.split = split_map[split]
for split in ["train", "test"]:
file_list = sorted(recursive_glob(rootdir=self.root + split + '/', suffix='jpg'))
self.files[split] = file_list
for split in ["train", "test"]:
file_list = sorted(recursive_glob(rootdir=self.root + 'annotations/' + split + '/', suffix='png'))
self.anno_files[split] = file_list
def __init__(self,
root,
split="train",
is_transform=False,
img_size=(480, 640),
augmentations=None,
img_norm=True):
"""__init__
:param root:
:param split:
:param is_transform:
:param img_size:
:param augmentations
"""
self.root = "/home/felix/projects/larynx/data/"
self.split = split
self.is_transform = is_transform
self.augmentations = augmentations
self.img_norm = img_norm
self.n_classes = 3
self.img_size = img_size if isinstance(img_size,
(tuple, list)) else (img_size,
img_size)
self.mean = np.array([103.939, 116.779, 123.68])
self.ignore_index = 250
self.files = {}
self.void_classes = []
self.valid_classes = [0, 1, 2]
self.class_map = dict(zip(self.valid_classes, range(self.n_classes)))
self.colors = [
[0, 0, 0],
[255, 0, 0],
[0, 0, 255],
]
self.label_colours = dict(zip(range(self.n_classes), self.colors))
self.class_names = ["background", "granuloma", "ulcerations"]
self.images_base = os.path.join(self.root, self.split, "images")
self.annotations_base = os.path.join(self.root, self.split,
"annotations")
self.files[split] = recursive_glob(rootdir=self.images_base,
suffix=".png")
if not self.files[split]:
raise Exception("No files for split=[%s] found in %s" %
(split, self.images_base))
print("Found %d %s images" % (len(self.files[split]), split))
def __init__(
self,
root,
split="train",
is_transform=False,
img_size=(316, 706),
augmentations=None,
img_norm=True,
version="tempest",
test_mode=False,
):
"""__init__
:param root:
:param split:
:param is_transform:
:param img_size:
:param augmentations
"""
self.root = root
self.split = split
self.is_transform = is_transform
self.augmentations = augmentations
self.img_norm = img_norm
self.n_classes = 2
self.img_size = img_size if isinstance(img_size, tuple) else (img_size,
img_size)
self.mean = np.array(self.mean_rgb[version])
self.files = {}
self.images_base = os.path.join(self.root, self.split, "sdr")
self.annotations_base = os.path.join(self.root, self.split, "labels")
self.files[split] = recursive_glob(rootdir=self.images_base,
suffix=".png")
self.void_classes = [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, -1]
self.valid_classes = [0, 1]
#self.void_classes = [ 255]
#self.valid_classes = [i for i in range(19)]
self.class_names = ["text", "background"]
self.ignore_index = 250
self.class_map = dict(zip(self.valid_classes, range(self.n_classes)))
if not self.files[split]:
raise Exception("No files for split=[%s] found in %s" %
(split, self.images_base))
print("Found %d %s images" % (len(self.files[split]), split))
def __init__(self, root, split="train", is_transform=False, img_size=(1024, 2048)):
"""__init__
:param root:
:param split:
:param is_transform:
:param img_size:
"""
self.root = root
self.split = split
self.is_transform = is_transform
self.n_classes = 20
self.img_size = img_size if isinstance(img_size, tuple) else (img_size, img_size)
self.mean = np.array([104.00699, 116.66877, 122.67892])
self.files = {}
self.images_base = os.path.join(self.root, 'leftImg8bit', self.split)
self.annotations_base = os.path.join(self.root, 'gtFine_trainvaltest', 'gtFine', self.split)
self.files[split] = recursive_glob(rootdir=self.images_base, suffix='.png')
self.void_classes = [0, 1, 2, 3, 4, 5, 6, 9, 10, 14, 15, 16, 18, 29, 30, -1]
self.valid_classes = [7, 8, 11, 12, 13, 17, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 31, 32, 33]
self.class_names = ['unlabelled', 'road', 'sidewalk', 'building', 'wall', 'fence',\
'pole', 'traffic_light', 'traffic_sign', 'vegetation', 'terrain',\
'sky', 'person', 'rider', 'car', 'truck', 'bus', 'train', \
'motorcycle', 'bicycle']
# Avg class size is used to weight instances during evaluation of iIoU
# Data from cityscapes evaluation script
# https://github.com/mcordts/cityscapesScripts/blob/master/cityscapesscripts/evaluation/evalPixelLevelSemanticLabeling.py
self.avg_class_size = [0,0,0,0,0,0,\
0,0,0,0,0,\
0,3462.4756337644,3930.4788056518,12794.0202738185,27855.1264367816,35732.1511111111,67583.7075812274,\
6298.7200839748,4672.3249222261]
self.classes_to_categories = [0,1,1,2,2,2,\
3,3,3,4,4,\
5,6,6,7,7,7,\
7,7]
self.category_names = ['void', 'flat', 'construction', 'object',
'nature', 'sky', 'human', 'vehicle']
self.class_map = dict(zip(self.valid_classes, range(1,20)))
if not self.files[split]:
raise Exception("No files for split=[%s] found in %s" % (split, self.images_base))
print("Found %d %s images" % (len(self.files[split]), split))
def __init__(self,
root,
split="train",
is_transform=False,
img_size=(1024, 2048)):
"""__init__
:param root:
:param split:
:param is_transform:
:param img_size:
"""
self.root = root
self.split = split
self.is_transform = is_transform
self.n_classes = 20
self.img_size = img_size if isinstance(img_size, tuple) else (img_size,
img_size)
self.mean = np.array([104.00699, 116.66877, 122.67892])
self.files = {}
self.images_base = os.path.join(self.root, 'leftImg8bit', self.split)
self.annotations_base = os.path.join(self.root, 'gtFine_trainvaltest',
'gtFine', self.split)
self.files[split] = recursive_glob(rootdir=self.images_base,
suffix='.png')
self.void_classes = [
0, 1, 2, 3, 4, 5, 6, 9, 10, 14, 15, 16, 18, 29, 30, -1
]
self.valid_classes = [
7, 8, 11, 12, 13, 17, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 31,
32, 33
]
self.class_names = ['unlabelled', 'road', 'sidewalk', 'building', 'wall', 'fence',\
'pole', 'traffic_light', 'traffic_sign', 'vegetation', 'terrain',\
'sky', 'person', 'rider', 'car', 'truck', 'bus', 'train', \
'motorcycle', 'bicycle']
self.class_map = dict(zip(self.valid_classes, range(1, 20)))
if not self.files[split]:
raise Exception("No files for split=[%s] found in %s" %
(split, self.images_base))
print("Found %d %s images" % (len(self.files[split]), split))
def __init__(
self,
root,
split="train",
is_transform=False,
img_size=(1024, 2048),
augmentations=None,
img_norm=True,
version="cityscapes",
test_mode = False,
n_classes = 1,
# ---------------------------------------------------------
# remove all image related inputs (e.g. rgb)
):
"""__init__
:param root:
:param split:
:param is_transform:
:param img_size:
:param augmentations
"""
self.root = root
self.split = split
self.is_transform = is_transform
self.augmentations = augmentations
self.img_norm = img_norm
self.n_classes = n_classes
self.img_size = img_size if isinstance(img_size, tuple) else (img_size, img_size)
self.files = {}
self.images_base = os.path.join(self.root, "leftImg8bit", self.split)
# add depth path
self.depths_base = os.path.join(self.root, "disparity", self.split)
self.files[split] = recursive_glob(rootdir=self.images_base, suffix=".png")
if not self.files[split]:
raise Exception("No files for split=[%s] found in %s" % (split, self.images_base))
print("Found %d %s images" % (len(self.files[split]), split))
def __init__(self,
root,
split="train",
is_transform=False,
img_size=(1024, 1024),
augmentations=None):
"""__init__
:param root:
:param split:
:param is_transform:
:param img_size:
:param augmentations
"""
self.root = root
self.split = split
self.is_transform = is_transform
self.augmentations = None
self.n_classes = 4
self.img_size = img_size if isinstance(img_size, tuple) else (img_size,
img_size)
self.mean = np.array([73.15835921, 82.90891754, 72.39239876])
self.files = {}
self.images_base = os.path.join(self.root, 'leftImg8bit', self.split)
self.annotations_base = os.path.join(self.root, 'gtFine_trainvaltest',
'gtFine', self.split)
self.files[split] = recursive_glob(rootdir=self.images_base,
suffix='.png')
self.void_classes = [0]
self.valid_classes = [250, 150, 70]
self.class_names = ['benign', 'in situ', 'invasive']
self.ignore_index = 3
self.class_map = dict(zip(self.valid_classes, range(3)))
if not self.files[split]:
raise Exception("No files for split=[%s] found in %s" %
(split, self.images_base))
print("Found %d %s images" % (len(self.files[split]), split))
def __init__(
self,
root,
split="train",
is_transform=True,
img_size=(1024, 2048),
augmentations=None,
img_norm=True,
# version="cityscapes",
):
"""__init__
:param root:
:param split:
:param is_transform:
:param img_size:
:param augmentations
"""
self.root = root
self.split = split
self.is_transform = is_transform
self.augmentations = augmentations
self.img_norm = img_norm
self.img_size = (
img_size if isinstance(img_size, tuple) else (img_size, img_size)
)
# self.mean = np.array(self.mean_rgb[version])
self.files = {}
self.images_base = os.path.join(self.root, "leftImg8bit", self.split)
self.annotations_base = os.path.join(
self.root, "disparity", self.split
)
self.files[split] = recursive_glob(rootdir=self.images_base, suffix=".png")
if not self.files[split]:
raise Exception(
"No files for split=[%s] found in %s" % (split, self.images_base)
)
print("Found %d %s images" % (len(self.files[split]), split))
sys.stdout.flush()
def __init__(self, root, split=["train"], is_transform=False,
img_size=(512, 1024), augmentations=None):
"""__init__
:param root:
:param split:
:param is_transform:
:param img_size:
:param augmentations
"""
self.root = root
self.split = split
self.split_text = '+'.join(split)
self.is_transform = is_transform
self.augmentations = augmentations
self.n_classes = 19
self.img_size = img_size if isinstance(img_size, tuple) else (img_size, img_size)
self.mean = np.array([73.15835921, 82.90891754, 72.39239876])
self.files = {}
self.files[self.split_text] = []
for _split in self.split:
self.images_base = os.path.join(self.root, 'leftImg8bit', _split)
self.annotations_base = os.path.join(self.root, 'gtFine', _split)
self.files[self.split_text] = recursive_glob(rootdir=self.images_base, suffix='.png')
self.void_classes = [0, 1, 2, 3, 4, 5, 6, 9, 10, 14, 15, 16, 18, 29, 30, -1]
self.valid_classes = [7, 8, 11, 12, 13, 17, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 31, 32, 33]
self.no_instances = [7, 8, 11, 12, 13, 17, 19, 20, 21, 22, 23]
self.class_names = ['unlabelled', 'road', 'sidewalk', 'building', 'wall', 'fence',\
'pole', 'traffic_light', 'traffic_sign', 'vegetation', 'terrain',\
'sky', 'person', 'rider', 'car', 'truck', 'bus', 'train', \
'motorcycle', 'bicycle']
self.ignore_index = 250
self.class_map = dict(zip(self.valid_classes, range(19)))
if len(self.files[self.split_text]) < 2:
raise Exception("No files for split=[%s] found in %s" % (self.split_text, self.images_base))
print("Found %d %s images" % (len(self.files[self.split_text]), self.split_text))
def __init__(self,
root,
split="training",
is_transform=False,
img_size=(240, 320),
splitRate=0.7):
self.root = root + 'imgs/'
self.n_classes = 10
self.split = split
self.splitRate = splitRate
self.is_transform = is_transform
self.img_size = img_size if isinstance(img_size, tuple) else (img_size,
img_size)
self.mean = np.array(
[122.5454, 104.7834, 100.0239, 134.5181, 110.9748, 137.2213])
self.files_rgb = recursive_glob(rootdir=self.root + 'rgb/',
suffix='.png')
self.datasize = len(self.files_rgb)
self.startIndex = 0 if (split == "training") else int(self.datasize *
splitRate)
self.interestedLables = np.array(
[5, 11, 36, 49, 83, 88, 157, 158, 169])
def __init__(self, root, split="train", is_transform=False,
img_size=(512, 1024), augmentations=None):
"""__init__
:param root:
:param split:
:param is_transform:
:param img_size:
:param augmentations
"""
self.root = root
self.split = split
self.is_transform = is_transform
self.augmentations = augmentations
self.n_classes = 19
self.img_size = img_size if isinstance(img_size, tuple) else (img_size, img_size)
self.mean = np.array([73.15835921, 82.90891754, 72.39239876])
self.files = {}
self.images_base = os.path.join(self.root, 'leftImg8bit', self.split)
self.annotations_base = os.path.join(self.root, 'gtFine_trainvaltest', 'gtFine', self.split)
self.files[split] = recursive_glob(rootdir=self.images_base, suffix='.png')
self.void_classes = [0, 1, 2, 3, 4, 5, 6, 9, 10, 14, 15, 16, 18, 29, 30, -1]
self.valid_classes = [7, 8, 11, 12, 13, 17, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 31, 32, 33]
self.class_names = ['unlabelled', 'road', 'sidewalk', 'building', 'wall', 'fence',\
'pole', 'traffic_light', 'traffic_sign', 'vegetation', 'terrain',\
'sky', 'person', 'rider', 'car', 'truck', 'bus', 'train', \
'motorcycle', 'bicycle']
self.ignore_index = 250
self.class_map = dict(zip(self.valid_classes, range(19)))
if not self.files[split]:
raise Exception("No files for split=[%s] found in %s" % (split, self.images_base))
print("Found %d %s images" % (len(self.files[split]), split))
def __init__(
self,
root,
split="train",
is_transform=False,
img_size=(1024, 2048),
augmentations=None,
img_norm=True,
version="cityscapes",
test_mode=False,
):
"""__init__
:param root:
:param split:
:param is_transform:
:param img_size:
:param augmentations
"""
self.root = root
self.split = split
self.is_transform = is_transform
self.augmentations = augmentations
self.img_norm = img_norm
self.n_classes = 19
self.img_size = img_size if isinstance(img_size, tuple) else (img_size, img_size)
self.mean = np.array(self.mean_rgb[version])
self.files = {}
self.images_base = os.path.join(self.root, "leftImg8bit", self.split)
self.annotations_base = os.path.join(self.root, "gtFine", self.split)
self.files[split] = recursive_glob(rootdir=self.images_base, suffix=".png")
self.void_classes = [0, 1, 2, 3, 4, 5, 6, 9, 10, 14, 15, 16, 18, 29, 30, -1]
self.valid_classes = [
7,
8,
11,
12,
13,
17,
19,
20,
21,
22,
23,
24,
25,
26,
27,
28,
31,
32,
33,
]
#self.void_classes = [ 255]
#self.valid_classes = [i for i in range(19)]
self.class_names = [
"unlabelled",
"road",
"sidewalk",
"building",
"wall",
"fence",
"pole",
"traffic_light",
"traffic_sign",
"vegetation",
"terrain",
"sky",
"person",
"rider",
"car",
"truck",
"bus",
"train",
"motorcycle",
"bicycle",
]
self.ignore_index = 250
self.class_map = dict(zip(self.valid_classes, range(19)))
if not self.files[split]:
raise Exception("No files for split=[%s] found in %s" % (split, self.images_base))
print("Found %d %s images" % (len(self.files[split]), split))
def __init__(
self,
root,
split="train",
is_transform=False,
img_size=(512, 1024),
augmentations=None,
img_norm=True,
version="cityscapes",
test_mode=False,
):
"""__init__
:param root:
:param split:
:param is_transform:
:param img_size:
:param augmentations
"""
self.root = root
#print(root)
self.split = split
self.is_transform = is_transform
self.augmentations = augmentations
self.img_norm = img_norm
self.n_classes = 2
self.img_size = img_size if isinstance(img_size, tuple) else (img_size,
img_size)
self.mean = np.array(self.mean_rgb[version])
print(self.mean)
self.files = {}
#self.q="/home/zaid/Documents/mask_rcnn_pytorvh/pytorch-semseg/gtFine/train_aug/"
self.images_base = os.path.join(self.root, "leftImg8bit", self.split)
self.annotations_base = os.path.join(self.root, "gtFine", self.split)
self.files[split] = recursive_glob(rootdir=self.images_base,
suffix=".jpg")
self.void_classes = [35, 36, 37, 38, 39]
# self.valid_classes = [
# 1,
# 2,
# 3,
# 4,
# 5,
# 6,
# 7,
# 8,
# 9,
# 10,
# 11,
# 12,
# 13,
# 14,
# 15,
# 16,
# 17,
# 18,
# 19,
# 20,
# 21,
# 22,
# 23,
# 24,
# 25,
# 26,
# 27,
# 28,
# 29,
# 30,
# 31,
# 32,
# 33,
# 34,
# 35,
# ]
self.valid_classes = [
#16 ,
#90 ,
0,
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
16,
17,
18,
19,
20,
21,
22,
23,
24,
25,
26,
27,
28,
29,
30,
31,
32,
33,
34,
35,
36,
37,
38,
39,
]
self.class_names = [
's_w_d',
's_y_d',
# 'ds_w_dn',
# 'ds_y_dn',
# 'sb_w_do',
# 'sb_y_do',
# 'b_w_g',
# 'b_y_g',
# 'db_w_g',
# 'db_y_g',
# 'db_w_s',
# 's_w_s',
# 'ds_w_s',
# 's_w_c',
# 's_y_c',
# 's_w_p',
# 's_n_p',
# 'c_wy_z',
# 'a_w_u',
# 'a_w_t',
# 'a_w_tl',
# 'a_w_tr',
# 'a_w_tlr',
# 'a_w_l',
# 'a_w_r',
# 'a_w_lr',
# 'a_n_lu',
# 'a_w_tu',
# 'a_w_m',
# 'a_y_t',
# 'b_n_sr',
# 'd_wy_za',
# 'r_wy_np',
# 'vom_wy_n',
# 'om_n_n',
]
self.ignore_index = 255
self.class_map = dict(zip(self.valid_classes, range(35)))
if not self.files[split]:
raise Exception("No files for split=[%s] found in %s" %
(split, self.images_base))
print("Found %d %s images" % (len(self.files[split]), split))
def __init__(
self,
cfg,
mode="train",
augmentations=None,
):
self.transductive = cfg["transductive"]
self.root = cfg["data_path"]
self.mode = mode
self.augmentations = augmentations
if mode == 'train':
self.split = cfg["train_split"]
elif mode == 'val':
self.split = cfg["val_split"]
self.files = {}
self.images_base = os.path.join(self.root, "Img", self.split)
self.annotations_base = os.path.join(self.root, "trainval59", self.split)
self.files[self.split] = recursive_glob(rootdir=self.annotations_base, suffix=".png")
self.n_classes = 59
self.void_classes = [0]
self.valid_classes = range(1,60)
self.class_map = dict(zip(self.valid_classes, range(59)))
self.unseen30 = [1, 2, 4, 8, 9, 11, 12, 13, 18, 19,
21, 22, 23, 24, 25, 26, 27, 29, 34, 35,
37, 38, 41, 43, 44, 46, 48, 54, 56, 58]
self.unseen20 = [2, 4, 11, 12, 13, 19, 21, 23, 24, 26,
34, 35, 37, 41, 43, 44, 46, 48, 51, 56]
self.unseen10 = [2, 12, 13, 26, 34, 35, 41, 43, 46, 51]
self.unseen5 = [2, 13, 34, 43, 51]
if cfg["unseen"] ==0:
self.unseen_classes = [] # Note that these should be choosen from IDs for valid categories
elif cfg["unseen"] ==5:
self.unseen_classes = self.unseen5 # Note that these should be choosen from IDs for valid categories
elif cfg["unseen"] ==10:
self.unseen_classes = self.unseen10 # Note that these should be choosen from IDs for valid categories
elif cfg["unseen"]==20:
self.unseen_classes = self.unseen20 # Note that these should be choosen from IDs for valid categories
elif cfg["unseen"]==30:
self.unseen_classes = self.unseen30 # Note that these should be choosen from IDs for valid categories
else:
raise Exception("Only support 10, 20, 30 unseen")
self.ignore_index = 250
self.embd = scio.loadmat(cfg["emdb_path"])["embd"]
self.embd = self.embd[self.valid_classes]
self.embeddings = torch.nn.Embedding(self.embd.shape[0], self.embd.shape[1])
self.embeddings.weight.requires_grad = False
self.embeddings.weight.data.copy_(torch.from_numpy(self.embd))
if not self.files[self.split]:
raise Exception("No files for split=[%s] found in %s" % (self.split, self.images_base))
print("Found %d %s images" % (len(self.files[self.split]), self.split))
def __init__(
self,
cfg,
mode="train",
augmentations=None,
):
self.transductive = cfg["transductive"]
self.root = cfg["data_path"]
self.mode = mode
self.augmentations = augmentations
if mode == 'train':
self.split = cfg["train_split"]
elif mode == 'val':
self.split = cfg["val_split"]
self.files = {}
self.images_base = os.path.join(self.root, "leftImg8bit", self.split)
self.annotations_base = os.path.join(self.root, "gtFine", self.split)
self.files[self.split] = recursive_glob(rootdir=self.images_base,
suffix=".png")
self.n_classes = 23
self.void_classes = [0, 1, 2, 3, 4, 5, 9, 14, 16, 18, 29, -1]
self.valid_classes = [
6, 7, 8, 10, 11, 12, 13, 15, 17, 19, 20, 21, 22, 23, 24, 25, 26,
27, 28, 30, 31, 32, 33
]
self.unseen12 = [0, 1, 4, 7, 8, 10, 12, 13, 15, 17, 18, 22]
self.unseen8 = [7, 8, 10, 12, 17, 18, 22]
self.unseen4 = [7, 10, 17, 22]
self.unseen2 = [17, 22]
if cfg["unseen"] == 0:
self.unseen_classes = [
] # Note that these should be choosen from IDs for valid categories
elif cfg["unseen"] == 2:
self.unseen_classes = self.unseen2 # Note that these should be choosen from IDs for valid categories
elif cfg["unseen"] == 4:
self.unseen_classes = self.unseen4 # Note that these should be choosen from IDs for valid categories
elif cfg["unseen"] == 8:
self.unseen_classes = self.unseen8 # Note that these should be choosen from IDs for valid categories
elif cfg["unseen"] == 12:
self.unseen_classes = self.unseen12 # Note that these should be choosen from IDs for valid categories
else:
raise Exception("Only support 4, 8, 12 unseen")
self.ignore_index = 250
self.class_map = dict(zip(self.valid_classes, range(23)))
self.embd = scio.loadmat(cfg["emdb_path"])["embd"]
self.embd = self.embd[self.valid_classes]
self.embeddings = torch.nn.Embedding(self.embd.shape[0],
self.embd.shape[1])
self.embeddings.weight.requires_grad = False
self.embeddings.weight.data.copy_(torch.from_numpy(self.embd))
if not self.files[self.split]:
raise Exception("No files for split=[%s] found in %s" %
(self.split, self.images_base))
print("Found %d %s images" % (len(self.files[self.split]), self.split))
def __init__(
self,
cfg,
mode="train",
augmentations=None,
):
self.transductive = cfg["transductive"]
self.root = cfg["data_path"]
self.mode = mode
self.augmentations = augmentations
if mode == 'train':
self.split = cfg["train_split"]
elif mode == 'val':
self.split = cfg["val_split"]
self.files = {}
self.images_base = os.path.join(self.root, "IMG", self.split)
self.annotations_base = os.path.join(self.root, "GT", self.split)
self.files[self.split] = recursive_glob(rootdir=self.annotations_base,
suffix=".png")
self.n_classes = 150
self.void_classes = [0]
self.valid_classes = range(1, 151)
self.unseen75 = [
1, 3, 4, 5, 6, 11, 13, 15, 18, 19, 20, 21, 24, 26, 29, 30, 31, 33,
34, 35, 38, 41, 43, 44, 45, 48, 50, 53, 55, 58, 59, 62, 63, 64, 70,
71, 75, 76, 77, 80, 82, 83, 84, 86, 87, 91, 92, 93, 94, 98, 99,
100, 104, 105, 109, 110, 112, 115, 120, 123, 124, 125, 126, 127,
128, 129, 133, 136, 137, 138, 139, 140, 143, 144, 147
] #Note that these should be choosen from IDs for valid categories
self.unseen50 = [
1, 3, 4, 5, 6, 13, 15, 18, 19, 20, 21, 24, 26, 29, 31, 33, 34, 35,
41, 43, 48, 50, 53, 58, 59, 62, 64, 71, 75, 80, 82, 83, 84, 86, 87,
91, 92, 93, 99, 109, 112, 123, 126, 127, 129, 133, 137, 138, 144,
147
]
self.unseen25 = [
1, 3, 6, 13, 15, 18, 21, 24, 29, 34, 35, 41, 50, 53, 71, 82, 83,
84, 91, 92, 99, 109, 126, 127, 133
]
self.unseen5 = [3, 18, 34, 50, 83]
if cfg["unseen"] == 0:
self.unseen_classes = [
] # Note that these should be choosen from IDs for valid categories
elif cfg["unseen"] == 5:
self.unseen_classes = self.unseen5 # Note that these should be choosen from IDs for valid categories
elif cfg["unseen"] == 25:
self.unseen_classes = self.unseen25 # Note that these should be choosen from IDs for valid categories
elif cfg["unseen"] == 50:
self.unseen_classes = self.unseen50 # Note that these should be choosen from IDs for valid categories
elif cfg["unseen"] == 75:
self.unseen_classes = self.unseen75 # Note that these should be choosen from IDs for valid categories
else:
raise Exception("Only support 5,25,50,75 unseen")
self.ignore_index = 250
self.class_map = dict(zip(self.valid_classes, range(150)))
self.embd = scio.loadmat(cfg["emdb_path"])["embd"]
self.embd = self.embd[self.valid_classes]
self.embeddings = torch.nn.Embedding(self.embd.shape[0],
self.embd.shape[1])
self.embeddings.weight.requires_grad = False
self.embeddings.weight.data.copy_(torch.from_numpy(self.embd))
if not self.files[self.split]:
raise Exception("No files for split=[%s] found in %s" %
(self.split, self.images_base))
print("Found %d %s images" % (len(self.files[self.split]), self.split))
def __init__(
self,
cfg,
mode="train",
augmentations=None,
):
self.transductive = cfg["transductive"]
self.root = cfg["data_path"]
self.mode = mode
self.augmentations = augmentations
if mode == 'train':
self.split = cfg["train_split"]
elif mode == 'val':
self.split = cfg["val_split"]
self.files = {}
self.images_base = os.path.join(self.root, "Img", self.split)
self.annotations_base = os.path.join(self.root, "trainval400",
self.split)
self.files[self.split] = recursive_glob(rootdir=self.annotations_base,
suffix=".mat")
self.n_classes = 215
self.void_classes = [
0, 1, 3, 4, 5, 7, 12, 13, 14, 16, 20, 21, 24, 29, 35, 38, 41, 47,
50, 52, 54, 63, 64, 67, 71, 73, 74, 76, 77, 79, 81, 82, 83, 84, 89,
91, 92, 93, 94, 95, 97, 99, 100, 101, 102, 103, 107, 108, 109, 111,
112, 114, 116, 117, 118, 119, 120, 121, 125, 126, 127, 129, 130,
131, 132, 133, 134, 135, 137, 139, 142, 143, 145, 146, 147, 151,
152, 153, 156, 157, 160, 161, 163, 164, 166, 167, 168, 171, 172,
173, 174, 175, 177, 178, 179, 180, 182, 183, 188, 192, 193, 197,
198, 200, 201, 202, 203, 205, 206, 209, 210, 212, 214, 215, 217,
218, 222, 224, 226, 227, 229, 230, 231, 233, 234, 235, 236, 237,
238, 239, 240, 241, 242, 243, 245, 246, 249, 253, 254, 255, 256,
257, 264, 267, 270, 274, 276, 278, 279, 280, 283, 285, 288, 292,
298, 299, 300, 301, 302, 304, 305, 310, 312, 313, 315, 317, 318,
321, 322, 325, 327, 328, 331, 332, 335, 336, 337, 338, 339, 340,
341, 343, 344, 345, 346, 348, 351, 352, 353, 358, 362, 364, 365,
367, 369, 370, 372, 375, 376, 379, 380, 381, 382, 385, 386, 387,
388, 389, 390, 391, 392, 393, 394, 395, 396, 398, 399, 401, 404,
407, 408, 409, 411, 414, 417, 421, 422, 423, 425, 426, 428, 429,
433, 439, 441, 442, 444, 447, 448, 449, 450, 451, 453, 455, 459
]
self.valid_classes = [
2, 6, 8, 9, 10, 11, 15, 17, 18, 19, 22, 23, 25, 26, 27, 28, 30, 31,
32, 33, 34, 36, 37, 39, 40, 42, 43, 44, 45, 46, 48, 49, 51, 53, 55,
56, 57, 58, 59, 60, 61, 62, 65, 66, 68, 69, 70, 72, 75, 78, 80, 85,
86, 87, 88, 90, 96, 98, 104, 105, 106, 110, 113, 115, 122, 123,
124, 128, 136, 138, 140, 141, 144, 148, 149, 150, 154, 155, 158,
159, 162, 165, 169, 170, 176, 181, 184, 185, 186, 187, 189, 190,
191, 194, 195, 196, 199, 204, 207, 208, 211, 213, 216, 219, 220,
221, 223, 225, 228, 232, 244, 247, 248, 250, 251, 252, 258, 259,
260, 261, 262, 263, 265, 266, 268, 269, 271, 272, 273, 275, 277,
281, 282, 284, 286, 287, 289, 290, 291, 293, 294, 295, 296, 297,
303, 306, 307, 308, 309, 311, 314, 316, 319, 320, 323, 324, 326,
329, 330, 333, 334, 342, 347, 349, 350, 354, 355, 356, 357, 359,
360, 361, 363, 366, 368, 371, 373, 374, 377, 378, 383, 384, 397,
400, 402, 403, 405, 406, 410, 412, 413, 415, 416, 418, 419, 420,
424, 427, 430, 431, 432, 434, 435, 436, 437, 438, 440, 443, 445,
446, 452, 454, 456, 457, 458
]
self.unseen_classes = [
1, 2, 4, 5, 6, 7, 13, 14, 15, 16, 18, 21, 22, 23, 24, 25, 26, 30,
31, 32, 33, 34, 35, 36, 37, 39, 40, 41, 43, 45, 46, 48, 49, 52, 53,
54, 55, 56, 60, 61, 64, 65, 66, 67, 68, 69, 70, 71, 73, 74, 75, 76,
77, 81, 82, 83, 84, 85, 86, 87, 88, 91, 92, 93, 94, 95, 96, 97, 99,
100, 101, 102, 103, 105, 106, 107, 108, 110, 111, 112, 113, 114,
115, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,
131, 132, 134, 135, 136, 137, 138, 139, 140, 143, 144, 145, 146,
148, 149, 150, 151, 152, 153, 154, 157, 158, 159, 160, 161, 164,
167, 168, 169, 171, 172, 175, 176, 177, 178, 179, 180, 181, 183,
184, 185, 186, 187, 188, 189, 190, 193, 194, 198, 199, 200, 201,
202, 203, 204, 205, 207, 209, 210, 212, 213
] #Note that these should be choosen from IDs for valid categories
self.ignore_index = 250
self.class_map = dict(zip(self.valid_classes, range(215)))
self.embd = scio.loadmat(cfg["emdb_path"])["embd"]
self.embd = self.embd[self.valid_classes]
self.embeddings = torch.nn.Embedding(self.embd.shape[0],
self.embd.shape[1])
self.embeddings.weight.requires_grad = False
self.embeddings.weight.data.copy_(torch.from_numpy(self.embd))
if not self.files[self.split]:
raise Exception("No files for split=[%s] found in %s" %
(self.split, self.images_base))
print("Found %d %s images" % (len(self.files[self.split]), self.split))