def __init__(self,
model,
optimizer,
criterion,
data_loader,
valid_data_loader=None,
lr_scheduler=None,
scheduler_monitor_value=None,
l1_loss=False,
l1_factor=0.001):
if scheduler_monitor_value:
assert scheduler_monitor_value in [
None, 'loss', 'accuracy'
], 'scheduler_monitor_value can be either `loss` or `accuracy`'
self.device = enable_cuda()
self.model = model.to(self.device)
self.train_loader, self.test_loader = data_loader, valid_data_loader
self.do_validation = True if self.test_loader else False
self.lr_scheduler = lr_scheduler
self.scheduler_monitor_value = scheduler_monitor_value
self.l1_loss = l1_loss
self.l1_factor = l1_factor
self.optimizer = optimizer
self.criterion = criterion
def __init__(self,
model,
optimizer,
criterion,
data_loader,
valid_data_loader=None,
callbacks=None,
l1_loss=False,
l1_factor=0.001):
self.device = enable_cuda()
self.model = model.to(self.device)
self.train_loader, self.test_loader = data_loader, valid_data_loader
self.do_validation = True if self.test_loader else False
self.l1_loss = l1_loss
self.l1_factor = l1_factor
self.optimizer = optimizer
self.criterion = criterion
self.lr_schedulers = {
'step_lr': None,
'plateau_lr': None,
'one_cycle_lr': None
}
if callbacks is not None:
self._make_schedulers(callbacks)
def plot_gradcam(image,
model,
layer,
model_path=None,
classes=None,
class_id=None,
save_as_file=False,
**kwargs):
"""
@param image: image object
@param image_path:
"""
assert type(image) in [
str, torch.Tensor
], '`image` param can be either `str` if path of image is given or `torch.Tensor` for processed image'
device = enable_cuda()
image, original_image = load_images(image, **kwargs)
image = torch.stack(image).to(device)
if model_path:
model.load_state_dict(torch.load(model_path))
model.to(device)
model.eval()
gcam = GradCAM(model=model, candidate_layers=layer)
probs, ids = gcam.forward(image, original_image[0])
if class_id and classes:
assert type(class_id) is int, "class id value must be an integer."
if class_id in range(len(classes)):
ids = torch.tensor([[class_id]], dtype=torch.int64).to(device)
probs = torch.tensor([[probs[0, class_id]]])
else:
raise ValueError('class id is not present in classes.')
gcam.backward(ids=ids[:, [0]])
region = gcam.generate(target_layer=layer)
print(
f" #GRADCAM: {classes[ids[0, 0]] if classes else ids[0, 0]} (prob : {probs[0, 0]})"
)
# Grad-CAM save
out = save_gradcam(
filename=
f"gradcam-{model.__class__.__name__}-{layer}-{classes[ids[0, 0]] if classes else ids[0, 0]}.png",
gcam=region[0, 0],
raw_image=original_image[0],
save_as_file=save_as_file)
gcam.remove_hook()
return out
def __init__(self, model, optimizer, criterion, data_loader, valid_data_loader=None, lr_scheduler=None,
l1_loss=False, l1_factor=0.001):
self.device = enable_cuda()
self.model = model.to(self.device)
self.train_loader, self.test_loader = data_loader, valid_data_loader
self.do_validation = True if self.test_loader else False
self.lr_scheduler = lr_scheduler
self.l1_loss = l1_loss
self.l1_factor = l1_factor
self.optimizer = optimizer
self.criterion = criterion
def plot_gradcam(image_path,
model,
layer,
model_path=None,
classes=None,
class_id=None,
**kwargs):
device = enable_cuda()
image, original_image = load_images(image_path, **kwargs)
image = torch.stack(image).to(device)
if model_path:
model.load_state_dict(torch.load(model_path))
model.to(device)
model.eval()
gcam = GradCAM(model=model, candidate_layers=layer)
probs, ids = gcam.forward(image, original_image[0])
if class_id and classes:
assert type(class_id) is int, "class id value must be an integer."
if class_id in range(len(classes)):
ids = torch.tensor([[class_id]], dtype=torch.int64).to(device)
probs = torch.tensor([[probs[0, class_id]]])
else:
raise ValueError('class id is not present in classes.')
gcam.backward(ids=ids[:, [0]])
region = gcam.generate(target_layer=layer)
print(
f" #GRADCAM: {classes[ids[0, 0]] if classes else ids[0, 0]} (prob : {probs[0, 0]})"
)
# Grad-CAM save
save_gradcam(
filename=
f"gradcam-{model.__class__.__name__}-{layer}-{classes[ids[0, 0]] if classes else ids[0, 0]}.png",
gcam=region[0, 0],
raw_image=original_image[0])
gcam.remove_hook()
def class_wise_accuracy(model, model_path, test_loader, classes):
incorrect_map = {}
total_map = {}
for i in range(len(classes)):
incorrect_map[i] = 0
total_map[i] = 0
# identifying device
device = enable_cuda()
# Load the model
model.load_state_dict(torch.load(model_path))
model.to(device)
model.eval()
# Identify misclassified images
with torch.no_grad():
for data, target in test_loader:
data, target = data.to(device), target.to(device)
output = model(data)
pred = output.argmax(
dim=1,
keepdim=True) # get the index of the max log-probability
result = pred.eq(target.view_as(pred))
target_list = list(target.view_as(pred))
for i in range(test_loader.batch_size):
total_map[target_list[i]] += 1
if not list(result)[i]:
incorrect_map[target_list[i]] += 1
return {
classes[x]: (total_map[x] - incorrect_map[x]) / total_map[x]
for x in total_map
}
def identify_misclassification(model, model_path, test_loader, limit=25):
incorrect_samples = []
# identifying device
device = enable_cuda()
# Load the model
model.load_state_dict(torch.load(model_path))
model.to(device)
model.eval()
# Identify misclassified images
with torch.no_grad():
for data, target in test_loader:
images = data
data, target = data.to(device), target.to(device)
output = model(data)
pred = output.argmax(
dim=1,
keepdim=True) # get the index of the max log-probability
result = pred.eq(target.view_as(pred))
# Save incorrect samples
if len(incorrect_samples) < limit:
for i in range(test_loader.batch_size):
if not list(result)[i]:
incorrect_samples.append({
'prediction':
list(pred)[i],
'label':
list(target.view_as(pred))[i],
'image':
list(images)[i]
})
return incorrect_samples
