def gen_train_val_loader(labeled_scene_index, **kwargs):
labeled_scene_index_shuf = labeled_scene_index
random.shuffle(labeled_scene_index_shuf)
train_labeled_scene_index = labeled_scene_index_shuf[:
-10] #hard code we know there are only 28 scenes that are labeled
val_labeled_scene_index = labeled_scene_index_shuf[-10:]
print(len(train_labeled_scene_index), len(val_labeled_scene_index))
print(train_labeled_scene_index[0], val_labeled_scene_index[0])
loadkwargs = {
'batch_size': 2,
'shuffle': True,
'collate_fn': collate_fn,
'num_workers': 2,
}
labeled_trainset = LabeledDataset(scene_index=train_labeled_scene_index,
**kwargs)
print(len(labeled_trainset))
trainloader = torch.utils.data.DataLoader(labeled_trainset, **loadkwargs)
labeled_valset = LabeledDataset(scene_index=val_labeled_scene_index,
**kwargs)
print(len(labeled_valset))
valloader = torch.utils.data.DataLoader(labeled_valset, **loadkwargs)
result = {"train": trainloader, "val": valloader}
return result
def LoadData(depth_folder, image_folder, annotation_csv, args):
train_labeled_scene_index = np.arange(106, 131) #128
val_labeled_scene_index = np.arange(131, 134) #134
labeled_trainset = LabeledDataset(depth_folder=depth_folder,
image_folder=image_folder,
annotation_file=annotation_csv,
scene_index=train_labeled_scene_index,
transform=(transform, transform_depth),
extra_info=True)
labeled_valset = LabeledDataset(depth_folder=depth_folder,
image_folder=image_folder,
annotation_file=annotation_csv,
scene_index=val_labeled_scene_index,
transform=(transform, transform_depth),
extra_info=True)
trainloader = torch.utils.data.DataLoader(
labeled_trainset,
batch_size=args.per_gpu_batch_size,
shuffle=True,
num_workers=4,
collate_fn=collate_fn,
pin_memory=True)
valloader = torch.utils.data.DataLoader(labeled_valset,
batch_size=args.per_gpu_batch_size,
shuffle=True,
num_workers=4,
collate_fn=collate_fn,
pin_memory=True)
return trainloader, valloader
def LoadData(image_folder, annotation_csv): train_labeled_scene_index = np.arange(106, 128) val_labeled_scene_index = np.arange(128, 134) labeled_trainset = LabeledDataset(image_folder=image_folder, annotation_file=annotation_csv, scene_index=train_labeled_scene_index, transform=transform, extra_info=True) labeled_valset = LabeledDataset(image_folder=image_folder, annotation_file=annotation_csv, scene_index=val_labeled_scene_index,transform=transform,extra_info=True) trainloader = torch.utils.data.DataLoader(labeled_trainset, batch_size=8, shuffle=True, num_workers=2, collate_fn=collate_fn) valloader = torch.utils.data.DataLoader(labeled_valset, batch_size=8, shuffle=True, num_workers=2, collate_fn=collate_fn) return trainloader, valloader
def get_dataloader(batch_size, indices, data_dir):
labeled_scene_index = np.arange(106, 134)
val_sampler = SubsetRandomSampler(indices)
transform = torchvision.transforms.Compose([
torchvision.transforms.ToTensor(),
torchvision.transforms.Normalize((0.5563, 0.6024, 0.6325),
(0.3195, 0.3271, 0.3282))
])
image_folder = data_dir
annotation_csv = f'{data_dir}/annotation.csv'
labeled_trainset = LabeledDataset(image_folder=image_folder,
annotation_file=annotation_csv,
scene_index=labeled_scene_index,
transform=transform,
extra_info=True)
val_loader = torch.utils.data.DataLoader(labeled_trainset,
batch_size=batch_size,
num_workers=8,
pin_memory=True,
collate_fn=collate_fn,
sampler=val_sampler)
return val_loader
def LoadData(image_folder, annotation_csv, args):
train_labeled_scene_index = np.arange(106, 131)
val_labeled_scene_index = np.arange(131, 134)
extra_transforms = [data_transforms, data_jitter_brightness, data_jitter_hue, data_jitter_contrast, data_jitter_saturation]
extra_datasets = []
for t in extra_transforms:
extra_datasets.append(LabeledDataset(image_folder=image_folder, annotation_file=annotation_csv,scene_index=train_labeled_scene_index, transform=t, extra_info=True))
trainloader = torch.utils.data.DataLoader(torch.utils.data.ConcatDataset(extra_datasets), batch_size=args.per_gpu_batch_size, shuffle=True, num_workers=4, collate_fn=collate_fn, pin_memory = True)
labeled_valset = LabeledDataset(image_folder=image_folder, annotation_file=annotation_csv,
scene_index=val_labeled_scene_index,transform=transform,extra_info=True)
valloader = torch.utils.data.DataLoader(labeled_valset, batch_size=args.per_gpu_batch_size, shuffle=True, num_workers=4, collate_fn=collate_fn, pin_memory = True)
return trainloader, valloader
def prepare_data(self):
# The scenes from 106 - 133 are labeled
labeled_scene_index = np.arange(106, 134)
# Actually used during training and validation
# Keeping aside last 8 scenes for validation
# self._train_labeled_scene_index = labeled_scene_index[:-8]
# self._valid_labeled_scene_index = labeled_scene_index[-8:]
# Modification for submission (training on entire data)
# Not removing the validation scenes to avoid changing other parts of
# the code. Though validation here does not make sense.
self._train_labeled_scene_index = labeled_scene_index[:]
self._valid_labeled_scene_index = labeled_scene_index[-14:]
self._static_transform = torchvision.transforms.Compose([
torchvision.transforms.Resize((224, 224)),
torchvision.transforms.ToTensor(),
torchvision.transforms.Normalize((0.54, 0.60, 0.63),
(0.34, 0.34, 0.34)),
])
self.labeled_trainset = LabeledDataset(
image_folder=IMAGE_FOLDER,
annotation_file=ANNOTATION_CSV,
scene_index=self._train_labeled_scene_index,
transform=self._static_transform,
extra_info=False,
)
self.labeled_validset = LabeledDataset(
image_folder=IMAGE_FOLDER,
annotation_file=ANNOTATION_CSV,
scene_index=self._valid_labeled_scene_index,
transform=self._static_transform,
extra_info=False,
)
def read_data(self,
labeled = True # whether to read labeled data
):
"""
Load data and split to train/validation
--------------------
Return:
train - training dataset
val - validation dataset
"""
train = None
val = None
if labeled:
subset = 'labeled'
indices = self.labeled_scene_index
else:
subset = 'unlabeled'
indices = self.unlabeled_scene_index
cache_file = os.path.join(self.cached, subset+'.pt')
if os.path.exists(cache_file):
log.info('Loading from cached file: {}'.format(cache_file))
loaded = torch.load(cache_file)
train, val = (loaded['train'],
loaded['val'])
else:
if labeled:
dataset = LabeledDataset(image_folder = self.data_dir,
annotation_file = self.annotation_csv,
scene_index = indices,
transform = self.transform,
extra_info = False)
else:
dataset = UnlabeledDataset(image_folder = self.data_dir,
scene_index = indices,
first_dim = 'sample',
transform = self.transform)
val_size = int(len(dataset)*self.split)
train_size = int(len(dataset)-val_size)
return torch.utils.data.random_split(dataset,[train_size, val_size])
def __getitem__(self, index):
sample, target, road_image = LabeledDataset.__getitem__(self, index)
road_image = road_image.int()
for i, bb in enumerate(target['bounding_box']):
point_squence = torch.stack(
[bb[:, 0], bb[:, 1], bb[:, 3], bb[:, 2], bb[:, 0]])
x = (point_squence.T[0] * 10 + 400).int()
y = (-point_squence.T[1] * 10 + 400).int()
bottom = y.min()
top = y.max()
left = x.min()
right = x.max()
road_image[bottom:top, left:right] = target['category'][i]
return sample, road_image.long()
def test():
image_folder = '../dl/data'
annotation_csv = '../dl/data/annotation.csv'
labeled_scene_index = np.arange(106, 128)
labeled_scene_index_test = np.arange(130, 131)
transform = get_transform()
labeled_trainset = LabeledDataset(image_folder=image_folder,
annotation_file=annotation_csv,
scene_index=labeled_scene_index,
transform=transform,
extra_info=True)
trainloader = torch.utils.data.DataLoader(labeled_trainset,
batch_size=2,
shuffle=True,
num_workers=0,
collate_fn=collate_fn)
sample, target, road_image, extra = iter(trainloader).next()
loader = ModelLoader()
parser.add_argument('--testset', action='store_true')
parser.add_argument('--verbose', action='store_true')
opt = parser.parse_args()
image_folder = opt.data_dir
annotation_csv = f'{opt.data_dir}/annotation.csv'
if opt.testset:
labeled_scene_index = np.arange(134, 148)
else:
labeled_scene_index = np.arange(120, 134)
# For bounding boxes task
labeled_trainset_task1 = LabeledDataset(image_folder=image_folder,
annotation_file=annotation_csv,
scene_index=labeled_scene_index,
transform=get_transform_task1(),
extra_info=False)
dataloader_task1 = torch.utils.data.DataLoader(labeled_trainset_task1,
batch_size=1,
shuffle=False,
num_workers=0)
# For road map task
labeled_trainset_task2 = LabeledDataset(image_folder=image_folder,
annotation_file=annotation_csv,
scene_index=labeled_scene_index,
transform=get_transform_task2(),
extra_info=False)
dataloader_task2 = torch.utils.data.DataLoader(labeled_trainset_task2,
batch_size=1,
shuffle=False,
device = 'cuda'
image_folder = 'data'
annotation_csv = 'data/annotation.csv'
unlabeled_scene_index = np.arange(106)
labeled_scene_index = np.arange(106, 126)
labeled_scene_index_val = np.arange(126, 134)
epoch = 50
batchsize = 1
lr = 0.00001
transform = torchvision.transforms.ToTensor()
labeled_trainset = LabeledDataset(image_folder=image_folder,
annotation_file=annotation_csv,
scene_index=labeled_scene_index,
transform=transform,
extra_info=True
)
trainloader = torch.utils.data.DataLoader(labeled_trainset, batch_size=batchsize, shuffle=True, num_workers=1,
collate_fn=collate_fn)
labeled_valset = LabeledDataset(image_folder=image_folder,
annotation_file=annotation_csv,
scene_index=labeled_scene_index_val,
transform=transform,
extra_info=True
)
valloader = torch.utils.data.DataLoader(labeled_valset, batch_size=batchsize, shuffle=True, num_workers=2,
collate_fn=collate_fn)
model = YOLOv1_resnet().to(device)
criterion = Loss_yolov1()
# The scenes from 106 - 133 are labeled
# Divide the labeled_scene_index into two subsets (training and validation)
labeled_scene_index_tr = np.arange(106, 129)
labeled_scene_index_ts = np.arange(129, 134)
def get_transform():
return torchvision.transforms.Compose([
torchvision.transforms.Resize((224, 224)),
torchvision.transforms.ToTensor(),
torchvision.transforms.Normalize((0.4914, 0.4822, 0.4465),
(0.2023, 0.1994, 0.2010)),
])
labeled_trainset = LabeledDataset(image_folder=image_folder,
annotation_file=annotation_csv,
scene_index=labeled_scene_index_tr,
transform=get_transform(),
extra_info=True)
train_loader = torch.utils.data.DataLoader(labeled_trainset,
batch_size=args.batch_size,
shuffle=True,
num_workers=4,
collate_fn=collate_fn)
labeled_testset = LabeledDataset(image_folder=image_folder,
annotation_file=annotation_csv,
scene_index=labeled_scene_index_ts,
transform=get_transform(),
extra_info=True)
test_loader = torch.utils.data.DataLoader(labeled_testset,
batch_size=1,
def get_loaders(
data_type,
image_folder='/content/drive/My Drive/DL Project/data',
annotation_file='/content/drive/My Drive/DL Project/data/annotation.csv',
split_folder='data_utils',
batch_size=4,
extra_info=False,
visual=False):
"""
Args:
type (string): 'labeled' or 'unlabeled'
image_folder (string, optional): the location of the image folders
annotation_file (string, optional): the location of the annotations
split_folder (string, optional): the location of the split folder
batch_size (int, optional): how many samples to load per batch
extra_info (Boolean, optional): whether you want the extra information
"""
assert data_type in ['labeled', 'unlabeled'], "Set correct data_type"
if data_type == 'labeled':
train_labeled_scene_index = pickle.load(
open(os.path.join(split_folder, 'labeled_scene_index_train.p'),
'rb'))
val_labeled_scene_index = pickle.load(
open(os.path.join(split_folder, 'labeled_scene_index_val.p'),
'rb'))
if visual:
transform = transforms.ToTensor()
else:
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.698, 0.718, 0.730),
(0.322, 0.313, 0.308))
])
trainset = LabeledDataset(image_folder=image_folder,
annotation_file=annotation_file,
scene_index=train_labeled_scene_index,
transform=transform,
extra_info=extra_info)
valset = LabeledDataset(image_folder=image_folder,
annotation_file=annotation_file,
scene_index=val_labeled_scene_index,
transform=transform,
extra_info=extra_info)
trainloader = torch.utils.data.DataLoader(trainset,
batch_size=batch_size,
shuffle=True,
num_workers=2,
collate_fn=collate_fn)
valloader = torch.utils.data.DataLoader(valset,
batch_size=batch_size,
shuffle=False,
num_workers=2,
collate_fn=collate_fn)
else:
train_unlabeled_scene_index = pickle.load(
open(os.path.join(split_folder, 'unlabeled_scene_index_train.p'),
'rb'))
val_unlabeled_scene_index = pickle.load(
open(os.path.join(split_folder, 'unlabeled_scene_index_val.p'),
'rb'))
if visual:
transform = transforms.ToTensor()
else:
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.548, 0.597, 0.630),
(0.339, 0.340, 0.342))
])
trainset = UnlabeledDataset(
image_folder=image_folder,
first_dim='sample',
scene_index=train_unlabeled_scene_index,
transform=transform,
)
valset = UnlabeledDataset(image_folder=image_folder,
first_dim='sample',
scene_index=val_unlabeled_scene_index,
transform=transform)
trainloader = torch.utils.data.DataLoader(trainset,
batch_size=batch_size,
shuffle=True,
num_workers=2)
valloader = torch.utils.data.DataLoader(valset,
batch_size=batch_size,
shuffle=False,
num_workers=2)
return trainloader, valloader
transform = torchvision.transforms.Compose([torchvision.transforms.ToTensor(),
normalize
])
kwargs = {
#'first_dim': 'sample',
'transform': transform,
'image_folder': image_folder,
'annotation_file': annotation_csv,
'extra_info': True}
#dataset_train = LabeledDataset_RCNN (scene_index=train_labeled_scene_index, **kwargs)
#dataset_val = LabeledDataset_RCNN (scene_index=val_labeled_scene_index, **kwargs)
dataset_train = LabeledDataset(scene_index=train_labeled_scene_index, **kwargs)
dataset_val = LabeledDataset(scene_index=val_labeled_scene_index, **kwargs)
train_data_loader = torch.utils.data.DataLoader(
dataset_train, batch_size=30, shuffle=False, num_workers=4,
collate_fn=collate_fn)
val_data_loader = torch.utils.data.DataLoader(
dataset_val, batch_size=30, shuffle=False, num_workers=4,
collate_fn=collate_fn)
unlabeled_scene_index = np.arange(106)
labeled_scene_index_train = np.arange(106, 130)
labeled_scene_index_test = np.arange(130, 134)
"""
Evaluate trained generator model on test data (Qualitative)
"""
labeled_testset = LabeledDataset(image_folder=data_dir,
annotation_file=annotation_csv,
scene_index=labeled_scene_index_test,
img_transform=transforms.Compose([
transforms.Resize((256, 256)),
transforms.ToTensor(),
transforms.Normalize(mean=(0.5, ),
std=(0.5, ))
]),
map_transform=transforms.Compose([
transforms.ToPILImage(),
transforms.Resize(256),
transforms.ToTensor()
]),
extra_info=True)
testloader = torch.utils.data.DataLoader(labeled_testset,
batch_size=1,
shuffle=True,
num_workers=2,
collate_fn=collate_fn,
pin_memory=True)
print("Train scenes: {} \nVal scenes: {}".format(len(labeled_scene_index_train), len(labeled_scene_index_val)))
if opt.depth && !opt.precomputed:
# transform = MonoDepthEstimator("/scratch/dy1078/monodepth2/models/mono_model/models/weights_13/")
transform = MonoDepthEstimator("./models/weights_13/")
else:
transform = torchvision.transforms.ToTensor()
# The labeled dataset can only be retrieved by sample.
# And all the returned data are tuple of tensors, since bounding boxes may have different size
labeled_trainset = LabeledDataset(image_folder=image_folder,
annotation_file=annotation_csv,
scene_index=labeled_scene_index_train,
transform=transform,
extra_info=False,
precomputed=opt.precomputed
)
trainloader = torch.utils.data.DataLoader(labeled_trainset, batch_size=2, shuffle=True, num_workers=16, collate_fn=collate_fn)
labeled_valset = LabeledDataset(image_folder=image_folder,
annotation_file=annotation_csv,
scene_index=labeled_scene_index_val,
transform=transform,
extra_info=False,
precomputed=opt.precomputed
)
valloader = torch.utils.data.DataLoader(labeled_valset, batch_size=2, shuffle=True, num_workers=16, collate_fn=collate_fn)
