def __prepare_test__(self, root):
self.test_images_dict = Utility.load_images_to_dict(self.test_images_folder, "JPEG")
self.test_images_files = list(self.test_images_dict.keys())
self.test_truth_labels = Utility.loadTsvAsDict(join(self.test_annotations_folder, "val_annotations.txt"))
self.test_truth_labels = dict(
(join(self.test_images_folder, f), self.test_truth_labels[f]) for f in self.test_truth_labels)
self.data_size = len(self.test_images_files)
def test(self, loader, epoch_num):
Utility.cleanup()
log.info(f"Finished cleanup for epoch {epoch_num}")
self.model.eval()
pbar = tqdm(loader, ncols=1000)
total_loss = 0
summary_loss = 0
metrices = []
num_batches = len(loader)
log.info(f"Tester starting the testing for epoch: {epoch_num}")
with torch.no_grad():
for idx, data in enumerate(pbar):
x = torch.cat((data['bg'], data['fg_bg']), dim=1).to(device=self.device)
data['fg_bg_mask'] = data['fg_bg_mask'].to(self.device)
data['fg_bg_depth'] = data['fg_bg_depth'].to(self.device)
log.info(f"Starting the testing for batch:{idx}")
(loss, mask, depth) = self.__test_one_batch__(x, data['fg_bg_mask'], data['fg_bg_depth'])
log.info(f"End of the testing for batch:{idx}")
total_loss += loss
summary_loss += loss
if self.persister is not None:
self.persister(data, mask, epoch_num, "mask")
self.persister(data, depth, epoch_num, "depth")
log.info(f"Persisted the prediction for batch:{idx}")
if self.metric_fn is not None:
metric = self.metric_fn(data, mask)
metrices.append(metric)
log.info(f"Computed the metric for batch:{idx}")
if ((idx + 1) % 500 == 0 or idx == num_batches - 1):
self.writer.write_pred_summary(data, mask, depth)
l = summary_loss / 500
if idx == num_batches - 1:
l = summary_loss / ((idx + 1) % 500)
self.writer.write_scalar_summary('test loss', l, epoch_num * num_batches + idx)
summary_loss = 0
pbar.set_description(desc=f'Loss={loss}\t id={idx}\t')
log.info(f"For test batch {idx} loss is {loss}")
del loss, mask, depth, data
log.info(f"Completed the training for batch:{idx}")
metric = None
if self.metric_fn is not None:
metric = self.metric_fn.aggregate(metrices)
return PredictionResult(total_loss / len(loader.dataset), metric)
def showRandomImages(data, targets, predictions=None, classes=None, count=20, muSigmaPair=None):
randImages = Utility.pickRandomElements(data, count)
images = data[randImages]
if (muSigmaPair is not None):
images = Utility.unnormalize(images, muSigmaPair[0], muSigmaPair[1])
images = images.permute(0, 2, 3, 1)
targets = __getLabels(targets, randImages, classes)
if predictions is not None:
predictions = __getLabels(predictions, randImages, classes)
showImages(images.numpy(), targets, predictions, cols=5)
def download_CIFAR10(train_transforms, test_transforms, batch_size=128, isCuda=Utility.isCuda()):
"""
Load CIFAR10 dataset. Uses the provided train_transforms and the test_transforms and create a object of Data.
:param train_transforms: Transfomrations for train
:param test_transforms: Transformations for test
:param batch_size: Default value is 128
:param isCuda: Default value is True
:return: Data
"""
dataloader_args = dict(shuffle=True, batch_size=batch_size, num_workers=4, pin_memory=True) if isCuda else dict(
shuffle=True, batch_size=batch_size)
train_data = datasets.CIFAR10("../data", train=True, transform=train_transforms, download=True)
train_loader = torch.utils.data.DataLoader(train_data, **dataloader_args)
test_data = datasets.CIFAR10("../data", train=False, transform=test_transforms, download=True)
test_loader = torch.utils.data.DataLoader(test_data, **dataloader_args)
print(f'Shape of a train data batch: {shape(train_loader)}')
print(f'Shape of a test data batch: {shape(test_loader)}')
print(f'Number of train images: {len(train_data.data)}')
print(f'Number of test images: {len(test_data.data)}')
classes = ('plane', 'car', 'bird', 'cat',
'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
return Data(train_loader, test_loader, classes)
def plt_images(images, start_idx):
for idx, img in enumerate(images):
img = img.to(Utility.getCpu())
plt.subplot(rows, cols, start_idx + idx)
plt.axis("off")
plt.imshow(np.asarray(img.squeeze()), cmap='gray')
return start_idx + len(images)
def __init__(self, model, loss_fn, persister=None, metric_fn=None, device=Utility.getDevice(),
summary_writer=ModelSummaryWriter(name="-test")):
self.device = device
self.loss_fn = loss_fn
self.model = model
self.persister = persister
self.metric_fn = metric_fn
self.writer = summary_writer
def visualize(self,
data,
data_targets,
classes,
count=5,
muSigPair=None,
figSize=(15, 15)):
heatmaps, cam_pred = self.gradCam(data)
randIndices = Utility.pickRandomElements(data, count)
rand_data, rand_targets, rand_cam_pred = data[
randIndices], data_targets[randIndices], cam_pred[randIndices]
rand_superImposedImages = {}
for layer in heatmaps:
rand_superImposedImages[layer] = self.superImpose(
rand_data, heatmaps[layer], muSigPair)
self.plot(Utility.toImages(rand_data, muSigPair), rand_targets,
rand_cam_pred, rand_superImposedImages, classes, figSize)
def showLoaderImages(loader, classes=None, count=20, muSigmaPair=None):
"""
Takes random images from the loader and shows the images.
Optionally Mean and Sigma pair can be passed to unnormalize data before showing the image.
:param muSigmaPair: Default is (0, 1)
"""
d, l = iter(loader).next()
randImages = Utility.pickRandomElements(d, count)
images = d[randImages]
if (muSigmaPair is not None):
images = Utility.unnormalize(images, muSigmaPair[0], muSigmaPair[1])
# Loader has the channel at 1 index. But the show images need channel at the end.
images = images.permute(0, 2, 3, 1)
labels = __getLabels(l, randImages, classes)
showImages(images.numpy(), labels, cols=5)
def __init__(self, model, loss_fn, optimizer, scheduler, persister=None, metric_fn=None,
device=Utility.getDevice(), run_name="-model-trainer",
summary_writer=None):
self.optimizer = optimizer
self.device = device
self.loss_fn = loss_fn
self.scheduler = scheduler
self.model = model
self.persister = persister
self.metric_fn = metric_fn
self.writer = summary_writer
def superImpose(self, data, heatMapImages, muSigPair):
superImposedImages = []
images = Utility.toImages(data, muSigPair)
for i, image in enumerate(images):
image = np.uint8(255 * image)
heatmap = 1 - heatMapImages[i]
heatmap = np.uint8(255 * heatmap.squeeze())
heatmap = cv2.applyColorMap(heatmap, cv2.COLORMAP_JET)
superImposed = cv2.addWeighted(image, 0.5, heatmap, 0.5, 0)
superImposedImages.append(superImposed)
return superImposedImages
def __init__(self, model, data, loss_fn, optimizer, checkpoint=None, model_path=None, scheduler=None,
metric_fn=None,
train_pred_persister=None, test_pred_persister=None, device=Utility.getDevice(),
train_summary_writer=ModelSummaryWriter(name="-train"),
test_summary_writer=ModelSummaryWriter(name="-test")):
self.model = model
self.lossFn = loss_fn
self.optimizer = optimizer
self.data = data
self.checkpoint = checkpoint
self.model_path = model_path
self.trainer = ModelTrainer(model=model, loss_fn=loss_fn, optimizer=optimizer,
scheduler=optimizer if scheduler is None else scheduler,
metric_fn=metric_fn, persister=train_pred_persister,
summary_writer=train_summary_writer)
self.tester = ModelTester(model=model, loss_fn=loss_fn, persister=test_pred_persister, metric_fn=metric_fn,
device=device, summary_writer=test_summary_writer)
def test(self, model, loader, lossFn, device=Utility.getDevice()):
model.eval()
pbar = tqdm(loader, ncols=1000)
wholePred = []
wholeData = []
wholeTarget = []
totalLoss = 0
with torch.no_grad():
for idx, (data, target) in enumerate(pbar):
data, target = data.to(device), target.to(device)
(loss,
prediction) = self.__test_one_batch(model, data, target,
lossFn)
totalLoss += loss
wholePred.append(prediction)
wholeData.append(data)
wholeTarget.append(target)
return PredictionResult(torch.cat(wholeData), torch.cat(wholePred),
torch.cat(wholeTarget),
totalLoss / len(loader.dataset))
def main():
print("Gradcam Test")
net = models.resnet34(pretrained=True)
net.to(Utility.getDevice())
summary(net, input_size=(3, 224, 224))
classes = getImageNetClasses()
transforms = Compose([
ToTensor()
])
loader = DataUtility.loadImages("resources/processed-images", Alb(transforms))
layers = ["layer4", "layer3", "layer2", "layer1"]
cam = GradCam(net, layers)
analyzer = Analyzer(cam)
d, l = iter(loader).next()
analyzer.visualize(d, l, classes)
def fit(self, epoch, device=Utility.getDevice()):
train_accs = []
train_losses = []
test_accs = []
test_losses = []
learning_rates = []
for e in range(0, epoch):
print(f'\n\nEpoch: {e + 1}')
learning_rate = self.optimizer.param_groups[0]['lr']
learning_rates.append(learning_rate)
train_result = self.trainer.train_one_epoch(
self.model,
self.data.train,
self.optimizer,
device=device,
lossFn=self.lossFn,
scheduler=self.scheduler)
trainAcc = MetricsUtility.compute_accuracy(
train_result.predictions, train_result.targets)
train_accs.append(trainAcc)
train_losses.append(train_result.loss)
print(
f'Train Accuracy: {trainAcc}%, Train Loss: {train_result.loss}, Learning Rate: {learning_rate}'
)
test_result = self.tester.test(self.model,
self.data.test,
lossFn=self.lossFn,
device=device)
testAcc = MetricsUtility.compute_accuracy(test_result.predictions,
test_result.targets)
test_accs.append(testAcc)
test_losses.append(test_result.loss)
print(f'Test Accuracy: {testAcc}%, Test Loss: {test_result.loss}')
return ModelBuildResult(train_accs, train_losses, test_accs,
test_losses, learning_rates)
mean = (0.4914, 0.4822, 0.4465)
std = (0.2023, 0.1994, 0.2010)
mean_array = np.array([*mean])
train_transforms = Compose([
PadIfNeeded(40, 40, always_apply=True, p=1.0),
RandomCrop(32, 32, always_apply=True, p=1.0),
HorizontalFlip(p=0.5),
Cutout(num_holes=1, max_h_size=8, max_w_size=8, fill_value=np.array([*mean]) * 255.0, p=0.75),
Normalize(mean, std),
ToTensor()
])
test_transforms = Compose([
Normalize(mean, std),
ToTensor()
])
data = DataUtility.download_CIFAR10(Alb(train_transforms), Alb(test_transforms), batch_size=512)
criterion = F.nll_loss
net = S11Resnet().to(Utility.getDevice())
optimizer = optim.SGD(net.parameters(), lr = 1e-5, momentum=0.9)
finder = LRFinder(net, optimizer, criterion, Utility.getDevice())
finder.range_test(data.train, val_loader=data.test, start_lr=1e-5, end_lr=1e-4,
num_iter=2, step_mode="linear")
finder.plot()
finder.reset()
def loadTinyImagenet(data_folder, train_transforms, test_transforms, batch_size=128, isCuda=Utility.isCuda()):
dataloader_args = dict(shuffle=True, batch_size=batch_size, num_workers=4, pin_memory=True) if isCuda else dict(
shuffle=True, batch_size=batch_size)
train_data = ImageNet.TinyImageNet(data_folder, train=True, transform=train_transforms)
train_loader = torch.utils.data.DataLoader(train_data, **dataloader_args)
test_data = ImageNet.TinyImageNet(data_folder, train=False, transform=test_transforms)
test_loader = torch.utils.data.DataLoader(test_data, **dataloader_args)
print(f'Shape of a train data batch: {shape(train_loader)}')
print(f'Shape of a test data batch: {shape(test_loader)}')
print(f'Number of train images: {len(train_data)}')
print(f'Number of test images: {len(test_data)}')
return Data(train_loader, test_loader, train_data.idx_class)
def __load_classes__(self, root):
self.idx_class = Utility.loadFileToArray(root + "/wnids.txt")
self.class_idx = dict((c, i) for i, c in enumerate(self.idx_class))
trans = transforms.Compose([transforms.ToTensor()])
dataset = DepthDataset("data/tiny_data/", trans, trans, trans, trans)
train_dataset = torch.utils.data.Subset(dataset, list(range(8)))
test_dataset = torch.utils.data.Subset(dataset, list(range(16, 20)))
train_loader = torch.utils.data.DataLoader(train_dataset,
shuffle=True,
batch_size=2)
test_loader = torch.utils.data.DataLoader(test_dataset,
shuffle=True,
batch_size=2)
# dataset.show_images(5)
model = ResUNet(6, 1).to(Utility.getDevice())
summary(model, (6, 224, 224))
optimizer = optim.SGD(model.parameters(), lr=1e-5, momentum=0.9)
lossFn = Loss_fn(BCEWithLogitsLoss(), BCEWithLogitsLoss(), 1, 1)
builder = ModelBuilder(model=model,
optimizer=optimizer,
device=Utility.getDevice(),
loss_fn=lossFn,
scheduler=optimizer,
data=Data(train_loader, test_loader))
result = builder.fit(1)
print(result)
mean = (0.4914, 0.4822, 0.4465)
std = (0.2023, 0.1994, 0.2010)
mean_array = np.array([*mean])
train_transforms = Compose([
PadIfNeeded(40, 40, always_apply=True, p=1.0),
RandomCrop(32, 32, always_apply=True, p=1.0),
HorizontalFlip(p=0.5),
Cutout(num_holes=1,
max_h_size=8,
max_w_size=8,
fill_value=np.array([*mean]) * 255.0,
p=0.75),
Normalize(mean, std),
ToTensor()
])
test_transforms = Compose([Normalize(mean, std), ToTensor()])
data = DataUtility.download_CIFAR10(Alb(train_transforms),
Alb(test_transforms),
batch_size=512)
net = S11Resnet().to(Utility.getDevice())
optimizer = optim.SGD(net.parameters(), lr=0.01, momentum=0.9)
builder = ModelBuilder(net, data, LossFn(F.nll_loss, l2Factor=0.01, model=net),
optimizer)
result = builder.fit(1)
def train_one_epoch(self, loader, epoch_num):
Utility.cleanup()
log.info(f"Finished cleanup for epoch {epoch_num}")
self.model.train()
pbar = tqdm(loader, ncols=1000)
total_loss = 0
summary_loss = 0
metrices = []
num_batches = len(loader)
log.info(f"Trainer starting the training for epoch: {epoch_num}")
for idx, data in enumerate(pbar):
log.info(f"Obtained the data for batch:{idx}")
x = torch.cat((data['bg'], data['fg_bg']), dim=1).to(self.device)
data['fg_bg_mask'] = data['fg_bg_mask'].to(self.device)
data['fg_bg_depth'] = data['fg_bg_depth'].to(self.device)
log.info(f"Starting the training for batch:{idx}")
(loss, mask, depth) = self.__train_one_batch__(x, data['fg_bg_mask'], data['fg_bg_depth'])
log.info(f"End of the training for batch:{idx}")
total_loss += loss
summary_loss += loss
self.scheduler.step()
log.info(f"Scheduler step for the batch:{idx}")
if self.persister is not None:
self.persister(data, mask, epoch_num, "mask")
self.persister(data, depth, epoch_num, "depth")
log.info(f"Persisted the prediction for batch:{idx}")
if self.metric_fn is not None:
metric = self.metric_fn(data, mask)
metrices.append(metric)
log.info(f"Computed the metric for batch:{idx}")
lr = self.optimizer.param_groups[0]['lr']
pbar.set_description(desc=f'id={idx}\t Loss={loss}\t LR={lr}\t')
log.info(f"For train batch {idx} loss is {loss} and lr is {lr}")
if ((idx + 1) % 500 == 0 or idx == num_batches - 1):
self.writer.write_pred_summary(data, mask.detach(), depth.detach())
l = summary_loss / 500
if idx == num_batches - 1:
l = summary_loss / ((idx + 1) % 500)
self.writer.write_scalar_summary('train loss', l, epoch_num * num_batches + idx)
self.writer.write_scalar_summary('lr', lr, epoch_num * num_batches + idx)
summary_loss = 0
del loss, mask, depth, data
log.info(f"Completed the training for batch:{idx}")
metric = None
if self.metric_fn is not None:
metric = self.metric_fn.aggregate(metrices)
return PredictionResult(total_loss / len(loader.dataset), metric)
