def feature_set2(): for w1, w2, tag in pairs: s1, s2 = words[w1], words[w2] num_inter = len(s1.intersection(s2)) num_adiffb = len(s1.difference(s2)) num_bdiffa = len(s2.difference(s1)) ji = metrics.jaccard_index(s1, s2) ida = metrics.intersect_divide_a(s1, s2) idb = metrics.intersect_divide_b(s1, s2) dadu = metrics.diff_a_divide_union(s1, s2) dbdu = metrics.diff_b_divide_union(s1, s2) if tag == 'Yes': tag = 1 else: tag = -1 #out = [num_inter, num_adiffb, num_bdiffa, ji, ida, idb, dadu, dbdu, tag] #sent = "{},{},{},{},{},{},{},{}'{}'".format(*out) out = [ tag, num_inter, num_adiffb, num_bdiffa, ji, ida, idb, dadu, dbdu ] sent = "{} 1:{} 2:{} 3:{} 4:{} 5:{} 6:{} 7:{} 8:{}".format(*out) data.append(sent) print_features2_svm_format(data)
def feature_set2(): for w1, w2, tag in pairs: s1, s2 = words[w1], words[w2] num_inter = len(s1.intersection(s2)) num_adiffb = len(s1.difference(s2)) num_bdiffa = len(s2.difference(s1)) ji = metrics.jaccard_index(s1, s2) ida = metrics.intersect_divide_a(s1, s2) idb = metrics.intersect_divide_b(s1, s2) dadu = metrics.diff_a_divide_union(s1, s2) dbdu = metrics.diff_b_divide_union(s1, s2) if tag == 'Yes': tag = 1 else: tag = -1 #out = [num_inter, num_adiffb, num_bdiffa, ji, ida, idb, dadu, dbdu, tag] #sent = "{},{},{},{},{},{},{},{}'{}'".format(*out) out = [tag, num_inter, num_adiffb, num_bdiffa, ji, ida, idb, dadu, dbdu] sent = "{} 1:{} 2:{} 3:{} 4:{} 5:{} 6:{} 7:{} 8:{}".format(*out) data.append(sent) print_features2_svm_format(data)
def make_train_step(idx, data, model, optimizer, criterion, meters): # get the inputs and wrap in Variable if torch.cuda.is_available(): inputs = Variable(data['sat_img'].cuda()) labels = Variable(data['map_img'].cuda()) else: inputs = Variable(data['sat_img']) labels = Variable(data['map_img']) # zero the parameter gradients optimizer.zero_grad() # forward # prob_map = model(inputs) # last activation was a sigmoid # outputs = (prob_map > 0.3).float() outputs = model(inputs) # pay attention to the weighted loss should input logits not probs if args.lovasz_loss: loss, BCE_loss, DICE_loss = criterion(outputs, labels) outputs = torch.nn.functional.sigmoid(outputs) else: outputs = torch.nn.functional.sigmoid(outputs) loss, BCE_loss, DICE_loss = criterion(outputs, labels) # backward loss.backward() # https://github.com/asanakoy/kaggle_carvana_segmentation/blob/master/albu/src/train.py # torch.nn.utils.clip_grad_norm(model.parameters(), 1.) optimizer.step() meters["train_acc"].update(metrics.dice_coeff(outputs, labels), outputs.size(0)) meters["train_loss"].update(loss.data[0], outputs.size(0)) meters["train_IoU"].update(metrics.jaccard_index(outputs, labels), outputs.size(0)) meters["train_BCE"].update(BCE_loss.data[0], outputs.size(0)) meters["train_DICE"].update(DICE_loss.data[0], outputs.size(0)) meters["outputs"] = outputs return meters
def compile_model(model, num_classes, metrics, loss, lr): from keras.losses import binary_crossentropy from keras.losses import categorical_crossentropy from keras.metrics import binary_accuracy from keras.metrics import categorical_accuracy from keras.optimizers import Adam from metrics import dice_coeff from metrics import jaccard_index from metrics import class_jaccard_index from metrics import pixelwise_precision from metrics import pixelwise_sensitivity from metrics import pixelwise_specificity from metrics import pixelwise_recall from losses import focal_loss if isinstance(loss, str): if loss in {'ce', 'crossentropy'}: if num_classes == 1: loss = binary_crossentropy else: loss = categorical_crossentropy elif loss in {'focal', 'focal_loss'}: loss = focal_loss(num_classes) else: raise ValueError('unknown loss %s' % loss) if isinstance(metrics, str): metrics = [metrics, ] for i, metric in enumerate(metrics): if not isinstance(metric, str): continue elif metric == 'acc': metrics[i] = binary_accuracy if num_classes == 1 else categorical_accuracy elif metric == 'jaccard_index': metrics[i] = jaccard_index(num_classes) elif metric == 'jaccard_index0': metrics[i] = class_jaccard_index(0) elif metric == 'jaccard_index1': metrics[i] = class_jaccard_index(1) elif metric == 'jaccard_index2': metrics[i] = class_jaccard_index(2) elif metric == 'jaccard_index3': metrics[i] = class_jaccard_index(3) elif metric == 'jaccard_index4': metrics[i] = class_jaccard_index(4) elif metric == 'jaccard_index5': metrics[i] = class_jaccard_index(5) elif metric == 'dice_coeff': metrics[i] = dice_coeff(num_classes) elif metric == 'pixelwise_precision': metrics[i] = pixelwise_precision(num_classes) elif metric == 'pixelwise_sensitivity': metrics[i] = pixelwise_sensitivity(num_classes) elif metric == 'pixelwise_specificity': metrics[i] = pixelwise_specificity(num_classes) elif metric == 'pixelwise_recall': metrics[i] = pixelwise_recall(num_classes) else: raise ValueError('metric %s not recognized' % metric) model.compile(optimizer=Adam(lr=lr), loss=loss, metrics=metrics)
def test_jaccard_index(box1, box2, gt_iou): iou = jaccard_index(box1, box2) print("Is my jaccard index computation correct?", np.array_equal(iou, gt_iou))
def validation(valid_loader, model, criterion, logger, epoch_num): """ Args: train_loader: model: criterion: optimizer: epoch: Returns: """ # logging accuracy and loss valid_acc = metrics.MetricTracker() valid_loss = metrics.MetricTracker() valid_IoU = metrics.MetricTracker() valid_BCE = metrics.MetricTracker() valid_DICE = metrics.MetricTracker() log_iter = len(valid_loader) // logger.print_freq # switch to evaluate mode model.eval() # Iterate over data. for idx, data in enumerate(tqdm(valid_loader, desc='validation')): # get the inputs and wrap in Variable if torch.cuda.is_available(): inputs = Variable(data['sat_img'].cuda(), volatile=True) labels = Variable(data['map_img'].cuda(), volatile=True) else: inputs = Variable(data['sat_img'], volatile=True) labels = Variable(data['map_img'], volatile=True) # forward # prob_map = model(inputs) # last activation was a sigmoid # outputs = (prob_map > 0.3).float() outputs = model(inputs) # pay attention to the weighted loss should input logits not probs if args.lovasz_loss: loss, BCE_loss, DICE_loss = criterion(outputs, labels) outputs = torch.nn.functional.sigmoid(outputs) else: outputs = torch.nn.functional.sigmoid(outputs) loss, BCE_loss, DICE_loss = criterion(outputs, labels) valid_acc.update(metrics.dice_coeff(outputs, labels), outputs.size(0)) valid_loss.update(loss.data[0], outputs.size(0)) valid_IoU.update(metrics.jaccard_index(outputs, labels), outputs.size(0)) valid_BCE.update(BCE_loss.data[0], outputs.size(0)) valid_DICE.update(DICE_loss.data[0], outputs.size(0)) # tensorboard logging if idx % log_iter == 0: step = (epoch_num * logger.print_freq) + (idx / log_iter) # log accuracy and loss info = { 'loss': valid_loss.avg, 'accuracy': valid_acc.avg, 'IoU': valid_IoU.avg } for tag, value in info.items(): logger.scalar_summary(tag, value, step) # log the sample images log_img = [ data_utils.show_tensorboard_image(data['sat_img'], data['map_img'], outputs, as_numpy=True), ] logger.image_summary('valid_images', log_img, step) print( 'Validation Loss: {:.4f} BCE: {:.4f} DICE: {:.4f} Acc: {:.4f} IoU: {:.4f}' .format(valid_loss.avg, valid_BCE.avg, valid_DICE.avg, valid_acc.avg, valid_IoU.avg)) print() return { 'valid_loss': valid_loss.avg, 'valid_acc': valid_acc.avg, 'valid_IoU': valid_IoU.avg, 'valid_BCE': valid_BCE.avg, 'valid_DICE': valid_DICE.avg }