# In[8]:
visualize.display_instances(image, bbox, mask, class_ids, dataset.class_names)
# In[9]:
# Add augmentation and mask resizing.
image, image_meta, class_ids, bbox, mask = modellib.load_image_gt(
dataset, config, image_id, augment=True, use_mini_mask=True)
log("mask", mask)
display_images([image] +
[mask[:, :, i] for i in range(min(mask.shape[-1], 7))])
# In[10]:
mask = utils.expand_mask(bbox, mask, image.shape)
visualize.display_instances(image, bbox, mask, class_ids, dataset.class_names)
# ## Anchors
#
# The order of anchors is important. Use the same order in training and prediction phases. And it must match the order of the convolution execution.
#
# For an FPN network, the anchors must be ordered in a way that makes it easy to match anchors to the output of the convolution layers that predict anchor scores and shifts.
# * Sort by pyramid level first. All anchors of the first level, then all of the second and so on. This makes it easier to separate anchors by level.
# * Within each level, sort anchors by feature map processing sequence. Typically, a convolution layer processes a feature map starting from top-left and moving right row by row.
# * For each feature map cell, pick any sorting order for the anchors of different ratios. Here we match the order of ratios passed to the function.
#
# **Anchor Stride:**
# In the FPN architecture, feature maps at the first few layers are high resolution. For example, if the input image is 1024x1024 then the feature meap of the first layer is 256x256, which generates about 200K anchors (256*256*3). These anchors are 32x32 pixels and their stride relative to image pixels is 4 pixels, so there is a lot of overlap. We can reduce the load significantly if we generate anchors for every other cell in the feature map. A stride of 2 will cut the number of anchors by 4, for example.
#
# In this implementation we use an anchor stride of 2, which is different from the paper.
return oks_raw
for image_id in range(len(val_dataset_keypoints.image_ids)//2):
print(2*image_id, 2*image_id+1)
original_image1, image_meta1, gt_class_id1, gt_bbox1, gt_mask1, gt_keypoint1 =\
modellib.load_image_gt_keypoints(val_dataset_keypoints, inference_config,
2*image_id, augment=False,use_mini_mask=inference_config.USE_MINI_MASK)
original_image2, image_meta2, gt_class_id2, gt_bbox2, gt_mask2, gt_keypoint2 =\
modellib.load_image_gt_keypoints(val_dataset_keypoints, inference_config,
2*image_id+1, augment=False,use_mini_mask=inference_config.USE_MINI_MASK)
if(inference_config.USE_MINI_MASK):
gt_mask1 = utils.expand_mask(gt_bbox1,gt_mask1,original_image1.shape)
gt_mask2 = utils.expand_mask(gt_bbox2,gt_mask2,original_image2.shape)
results = model.detect_keypoint([original_image1, original_image2], verbose=0)
r1 = results[0]
r2 = results[1]
try:
AP.append(utils.compute_ap(gt_bbox1, gt_class_id1, gt_mask1, r1['rois'], r1['class_ids'], r1['scores'], r1['masks'])[0])
except ValueError:
print('predict no person')
AP.append(0)
try:
AP.append(utils.compute_ap(gt_bbox2, gt_class_id2, gt_mask2, r2['rois'], r2['class_ids'], r2['scores'], r2['masks'])[0])
def experiment1(model, optimizer, scheduler, dataloaders, dataset_sizes, num_epochs=25, viz = False):
#model to CUDA
model = model.to(device)
#out dirs
base_dir = Path.cwd() / 'outputs' / 'experiment1'
output_tracking_dir = base_dir / 'output_tracking'
logs_dir = base_dir / 'logs'
model_dir = base_dir / 'model'
logs_dir.mkdir(parents= True, exist_ok= True)
model_dir.mkdir(parents= True, exist_ok=True)
output_tracking_dir.mkdir(parents=True, exist_ok=True)
since = time.time()
PATH = str(model_dir / (model.name+'.pth'))
epo = 1
if Path(PATH).is_file():
checkpoint = torch.load(PATH)
model.load_state_dict(checkpoint['model_state_dict'])
optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
epo = checkpoint['epoch']
loss = checkpoint['loss']
scheduler.load_state_dict(checkpoint['scheduler_state_dict'])
print('Resuming from epoch ' + str(epo) + ', LOSS: ', loss)
best_model_wts = copy.deepcopy(model.state_dict())
best_loss = 3.0
logs_ptr = open(str(logs_dir/ 'train_logs'), 'a')
# pdb.set_trace()
for epoch in range(epo, epo + num_epochs):
epoch_str = 'Epoch {}/{}'.format(epoch, epo + num_epochs - 1) + '\n\n'
print(epoch_str)
logs_ptr.write(epoch_str)
print('-' * 10)
try:
# Each epoch has a training and validation phase
for phase in ['train', 'val']:
if phase == 'train':
model.train() # Set model to training mode
else:
model.eval() # Set model to evaluate mode
running_reg = 0.0
running_dice = 0.0
# Iterate over data.
times = 0
for mini_batch, (inputs, label224, label28) in enumerate(dataloaders[phase]):
inputs = inputs.to(device)
# labels size is (batch_size, 1, 224, 224)
label28 = label28.to(device)
# zero the parameter gradients
optimizer.zero_grad()
# forward
# track history if only in train
with torch.set_grad_enabled(phase == 'train'):
log_softmax_outputs28 = model(inputs) # shape of pred28 is (batch_size, 2, 28, 28)
softmax_outputs28 = torch.exp(log_softmax_outputs28)
output28_prob = get_prob_map28(softmax_outputs28)
reg_loss = torch.mean(
torch.sum(-torch.log(1.0 - torch.abs(output28_prob - label28)), dim=[1, 2, 3])
)/1000.0
dice_l = dice_loss(input=torch.round(output28_prob), target=torch.round(label28))
total_loss = reg_loss + 0.5*dice_l
# backward + optimize only if in training phase
if phase == 'train':
total_loss.backward()
optimizer.step()
if phase == 'train':
step_str = '{} Step {}- Loss: {:.4f}, Dice Loss: {:.4f}, Reg Loss: {:.4f}'\
.format(phase, mini_batch + 1,total_loss, dice_l, reg_loss)
print(step_str)
logs_ptr.write(step_str+'\n')
if phase == 'val' and viz:
output28_prob = output28_prob.cpu()
label28 = label28.cpu()
for item in range(label28.size(0)):
expanded_output28_prob = expand_mask([[0, 0, 224, 224]],
output28_prob[item].detach().numpy(),
(224, 224))
expanded_label28 = expand_mask([[0, 0, 224, 224]], label28[item].detach().numpy(),
(224, 224))
epoch_tracking_path = output_tracking_dir / str(epoch)
if not epoch_tracking_path.is_dir():
epoch_tracking_path.mkdir(parents=True, exist_ok=False)
actual_predicted(expanded_label28[0], expanded_output28_prob[0],
str(epoch_tracking_path / (str(mini_batch*label28.size(0) +item) + '.jpg') ) )
# statistics
# running_loss += step_loss.item() * inputs.size(0)
running_dice += dice_l.item() * inputs.size(0)
running_reg += reg_loss.item() * inputs.size(0)
# times+=1
# if times==2:
# break
# end of an epoch
# pdb.set_trace()
# epoch_loss = running_loss / dataset_sizes[phase]
epoch_dice_l = running_dice / dataset_sizes[phase]
epoch_reg_loss = running_reg / dataset_sizes[phase]
epoch_loss = epoch_dice_l + epoch_reg_loss
if phase == 'train':
scheduler.step()
loss_str = '\n{} Epoch {}: TotalLoss: {:.4f} RegLoss: {:.4f} Dice Loss: {:.4f} \n'.format(
phase, epoch, epoch_loss, epoch_reg_loss, epoch_dice_l) + '\n'
print(loss_str)
logs_ptr.write(loss_str + '\n')
# deep copy the model
if phase == 'val' and epoch_loss >= best_loss:
print('Val Dice better than Best Dice')
best_loss = epoch_loss
best_model_wts = copy.deepcopy(model.state_dict())
except:
# save model
save_model(epoch, best_model_wts, optimizer, scheduler, epoch_loss, PATH)
exit(0)
print()
time_elapsed = time.time() - since
print('Training complete in {:.0f}m {:.0f}s'.format(
time_elapsed // 60, time_elapsed % 60))
print('Best val DICE: {:4f}'.format(best_loss))
# save model
save_model(num_epochs,
best_model_wts,
optimizer,
scheduler, epoch_loss, PATH)