def get_similarity_values(q1_csc, q2_csc): cosine_sim = [] manhattan_dis = [] eucledian_dis = [] jaccard_dis = [] minkowsk_dis = [] for i, j in zip(q1_csc, q2_csc): sim = cs(i, j) cosine_sim.append(sim[0][0]) sim = md(i, j) manhattan_dis.append(sim[0][0]) sim = ed(i, j) eucledian_dis.append(sim[0][0]) i_ = i.toarray() j_ = j.toarray() try: sim = jsc(i_, j_) jaccard_dis.append(sim) except: jaccard_dis.append(0) sim = minkowski_dis.pairwise(i_, j_) minkowsk_dis.append(sim[0][0]) return cosine_sim, manhattan_dis, eucledian_dis, jaccard_dis, minkowsk_dis
def get_score(output, target): intersection = np.logical_and(target, output) union = np.logical_or(target, output) iou_score = np.sum(intersection)/ np.sum(union) y_true = target.reshape(-1) y_pred = output.reshape(-1) jacc_sim = jsc(y_true, y_pred, average=None) mean_jacc_sim = np.mean(jacc_sim) return iou_score, mean_jacc_sim
def train_epoch(epoch, model, device, data_loader, test_loader, optimizer, best_jaccard, best_loss): model.train() pid = os.getpid() for batch_idx, (data, target) in enumerate(data_loader): optimizer.zero_grad() output = model(data.to(device)) target = target.to(device) loss = loss_seg_fn( output.reshape(-1, ).to(device), target.reshape(-1, ).to(device)) target_cont = target[:, 0].data.cpu().numpy().reshape(-1) out_probs_cont = output[:, 0].data.cpu().numpy().reshape(-1) sampled_cont = (np.random.rand(len(out_probs_cont)) < out_probs_cont).astype(int) jaccard = jsc(target_cont, sampled_cont) loss.backward() optimizer.step() accs.append(loss.item()) conts.append(jaccard) if batch_idx % 32 == 0: val_jaccard = validate(test_loader, model, device) print( '{}\tTrain Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}\tJac: {:.6f}\tVal Jac: {:.6f}\tBest Val Jac: {:.6f}' .format(pid, epoch, batch_idx * len(data), len(data_loader.dataset), 100. * batch_idx / len(data_loader), np.mean(np.array(accs[-100:])), np.mean(np.array(conts[-100:])), val_jaccard, best_jaccard)) if val_jaccard > best_jaccard: best_jaccard = val_jaccard print('Saving model -- epoch no. ', epoch) torch.save( { 'epoch': epoch, 'jaccard': val_jaccard, 'model_state_dict': model.state_dict() }, './weights/nao.pt') model.train() if np.mean(np.array(accs[-100:])) < best_loss - 0.02: print('Saving overfit model -- epoch no. ', epoch) best_loss = np.mean(np.array(accs[-100:])) torch.save( { 'epoch': epoch, 'loss': best_loss, 'model_state_dict': model.state_dict() }, './weights/nao_overfit.pt') return best_jaccard, best_loss
def compute_iou(self, pred, target): """ Compute the IOU """ print("shape of the original prediction", np.shape(pred.cpu().data.numpy())) lbl = pred.cpu().data.numpy()[:,0,:,:].reshape(-1) > 0 tgt = target.cpu().data.numpy()[:,0,:,:].reshape(-1) print("shape of lbl in compute iou", np.shape(lbl)) print("shape of tgt in compute iou", np.shape(tgt)) return jsc(tgt, lbl)
def validation_IOU(prediction_batch, actual_batch): ''' NOT IN USE - mean_IOU is used ''' numpy_output = prediction_batch.cpu().numpy() prediction = np.argmax(numpy_output, axis=1) labels = actual_batch.cpu().numpy() jsc_labels = labels.reshape(-1) jsc_outputs = prediction.reshape(-1) return jsc(jsc_outputs, jsc_labels)
def compute_iou(self, pred, target): """ Compute the IOU """ if isinstance(pred, torch.Tensor): lbl = pred.cpu().data.numpy().reshape(-1) > 0 else: # this is a numpy array lbl = pred.reshape(-1) > 0 if isinstance(target, torch.Tensor): tgt = target.cpu().data.numpy().reshape(-1) else: # This is a numpy array tgt = target.reshape(-1) #print("shape of lbl in compute iou", np.shape(lbl)) #print("shape of tgt in compute iou", np.shape(tgt)) return jsc(tgt, lbl)
def calcul_iou_for_focal(net, dataset, gpu=False): tot = 0 for i, (img, true_mask) in enumerate(dataset): img = Variable(img) if gpu: img = img.cuda() pred_mask = net(img).cpu() pred_mask = pred_mask.data.numpy() true_mask = true_mask.numpy() pred_mask = np.argmax(pred_mask, axis=1) pred_mask = pred_mask.reshape(-1) true_mask = true_mask.reshape(-1) tot += jsc(pred_mask, true_mask) return tot / i
def compute_jaccard(gt, pred): """Function to compute Jaccard coefficient between two binary volumes Parameters ---------- gt : numpy array Ground truth volume. Must have dtype=np.uint8 pred : numpy array Predicted segmentation. Must have dtype=np.uint8 Returns ------- float Value of the Jaccard index """ jaccard = jsc(pred.flatten(), gt.flatten(), average = 'binary') return jaccard
def validate(test_loader, model, device, gamma=0.2): model.eval() losses = [] jaccards = [] with torch.no_grad(): for batch_idx, (data, target) in enumerate(test_loader): output = model(data.to(device)) target = target.to(device) loss = loss_seg_fn(output[:, 0].reshape(-1, ).to(device), target[:, 0].reshape(-1, ).to(device)) losses.append(loss.item()) target_cont = target[:, 0].data.cpu().numpy().reshape(-1) out_probs_cont = output[:, 0].data.cpu().numpy().reshape(-1) sampled_cont = (np.random.rand(len(out_probs_cont)) < out_probs_cont).astype(int) jaccard = jsc(target_cont, sampled_cont) jaccards.append(jaccard) return np.mean(np.array(jaccards))
def test(): jsc_list = [] data_loader = pascalVOCLoader data_path = "/home/temp_siplab/Datasets/VOCdevkit/VOC2012/" loader = data_loader(data_path, is_transform=True, split="train", img_size=(256, 256), ohe=False) n_classes = loader.n_classes testloader = data.DataLoader(loader, batch_size=batch_size, num_workers=4, shuffle=True) os.system("mkdir -p checkpoints") for i, (images, labels) in enumerate(testloader): if use_gpu: images = Variable(images.cuda()) labels = Variable(labels.cuda()) else: images = Variable(images) labels = Variable(labels) segmentor.zero_grad() output = segmentor(images) lbl = labels.cpu().numpy().reshape(-1) target = torch.max(output, dim=1)[1].cpu().detach().numpy().reshape(-1) jsc_list.append(jsc(target, lbl)) print(np.mean(jsc_list))
else: raise ValueError("Unknown loss") train_loss += loss.item() # backward loss and next step loss.backward() optimizer.step() # compute the accuracy # compute the accuracy lbl = y.cpu().numpy().reshape(-1) pred_labels = pred.detach().cpu().numpy().astype('float32') pred_labels = np.argmax(pred_labels, axis=1).reshape(-1).astype(np.uint8) batch_jacc = jsc(pred_labels, lbl, average='binary') print("Loss: ", loss.item()) print("Training - Batch JSC: ", batch_jacc) print("Num 1s: ", len(pred_labels[pred_labels > 0])) jaccs_train.append(batch_jacc) # ----------------------------- # validation samples # ----------------------------- # set the model into train mode lesion_model.eval( ) #Put in evaluation mode. Eg so that things like dropout don't occur during evaluation for b_v, (data, target) in enumerate(validation_dataloader): print("Validation. Mini-batch ", b_v + 1, "/",
jaccards = [] kls = [] sims = [] tracking = [0] contour_matching = [] with torch.no_grad(): for batch_idx, (test_images, test_labels) in enumerate(test_loader): flow = np.load(flow_val_data[count])[0].reshape(128, 228, 2) output = net(Variable(test_images).cuda().to(device)) out_probs_cont = output.data.cpu().numpy().reshape(-1) output_mask = (np.random.rand(len(out_probs_cont)) < out_probs_cont).astype(int) gt_mask = test_labels.reshape(-1, ).data.cpu().numpy() jaccard = jsc(gt_mask, output_mask) jaccards.append(jaccard) kl = KL(normalize(out_probs_cont), normalize(gt_mask.reshape(-1, ))) kls.append(kl) sim = histogram_intersection(gt_mask, output_mask) sims.append(sim) # if image_val_data[count].split('_')[2] == image_val_data[count-1].split('_')[2]: # coh_err = coherence_error(flow, prev_prediction, output_mask) # tracking.append(coh_err) # contour_pred, contour_gt = find_contours(output_mask, 1), find_contours(gt_mask, 1) #print(jaccard, kl, sim) prev_prediction = output_mask count += 1
print('-------- EPOCH {} -------'.format(epoch)) # TRAINING for i, (inputs, targets) in enumerate(train_data, 0): labels = targets.squeeze(1).type(torch.int64) if gpu: inputs = inputs.cuda() labels = labels.cuda() logits, y_pred = model(inputs) batch_iou = jsc( labels.cpu().numpy().reshape(-1), torch.argmax(y_pred, dim=1).cpu().numpy().reshape(-1), average='macro', ) tr_epoch_iou += batch_iou tr_batch_count += 1 # Zero gradients, perform a backward pass, and update the weights. optimizer.zero_grad() tr_loss = criterion(logits, labels) tr_epoch_loss += tr_loss.item() print("----- BATCH: {} TRAIN LOSS: {}".format(i, tr_loss.item())) # backprop tr_loss.backward() optimizer.step()
kls = [] sims = [] tracking = [0] contour_matching = [] for batch_idx, (test_images, test_labels) in enumerate(test_loader): gt_mask = test_labels.reshape(-1,).data.cpu().numpy() for i in range(len(test_labels)): gt_mask = test_labels[i].reshape(-1,).data.cpu().numpy() prec = precision_score(gt_mask, center) recall = recall_score(gt_mask, center) if prec + recall != 0: F = 2 * (prec * recall) / (prec + recall) Fs.append(F) jaccard = jsc(gt_mask, center) jaccards.append(jaccard) kl = KLD(center, gt_mask) kls.append(kl) sim = SIM(center, gt_mask) sims.append(sim) print('sim', np.mean(np.array(sims))) print('F', np.mean(np.array(Fs))) print('kl', np.mean(np.array(kls))) print('jacc', np.mean(np.array(jaccards)))
def get_jaccard(pred_bbox, truth_bbox): pred_mask = get_mask_from_bbox(pred_bbox) truth_mask = get_mask_from_bbox(truth_bbox) return jsc(y_true=truth_mask, y_pred=pred_mask, average='micro')
def coherence_error(flow, pred_1, pred_2): pred_1 = pred_1.reshape(128, 228) projected = cv2.remap(pred_1, flow, None, cv2.INTER_NEAREST) return jsc(pred_2, projected.reshape(-1, ))