def update_pbar(self, masks_predictions, masks_targets, pbar, average_meter, pbar_description): average_meter.add('iou', iou(masks_predictions > 0.5, masks_targets.byte())) average_meter.add('mAP', mAP(masks_predictions > 0.5, masks_targets.byte())) pbar.set_description( pbar_description + ''.join( [' {}:{:6.4f}'.format(k, v) for k, v in average_meter.get_all().items()] ) ) pbar.update()
def validation(valid_loader, model, criterion, num_classes, batch_size, classifier): """Args: valid_loader: validation data loader model: model to validate criterion: loss criterion num_classes: number of classes batch_size: number of samples to process simultaneously classifier: True if doing a classification task, False if doing semantic segmentation """ valid_metrics = create_metrics_dict(num_classes) model.eval() for index, data in enumerate(valid_loader): with torch.no_grad(): if classifier: inputs, labels = data if torch.cuda.is_available(): inputs = inputs.cuda() labels = labels.cuda() outputs = model(inputs) outputs_flatten = outputs else: if torch.cuda.is_available(): inputs = data['sat_img'].cuda() labels = flatten_labels(data['map_img']).cuda() else: inputs = data['sat_img'] labels = flatten_labels(data['map_img']) outputs = model(inputs) outputs_flatten = flatten_outputs(outputs, num_classes) loss = criterion(outputs_flatten, labels) valid_metrics['loss'].update(loss.item(), batch_size) # Compute metrics every 2 batches. Time consuming. if index % 2 == 0: a, segmentation = torch.max(outputs_flatten, dim=1) valid_metrics = report_classification(segmentation, labels, batch_size, valid_metrics) valid_metrics = iou(segmentation, labels, batch_size, valid_metrics) print('Validation Loss: {:.4f}'.format(valid_metrics['loss'].avg)) print('Validation iou: {:.4f}'.format(valid_metrics['iou'].avg)) print('Validation precision: {:.4f}'.format(valid_metrics['precision'].avg)) print('Validation recall: {:.4f}'.format(valid_metrics['recall'].avg)) print('Validation f1-score: {:.4f}'.format(valid_metrics['fscore'].avg)) return valid_metrics
def compile_model(model, num_classes, metrics, loss, lr): if isinstance(loss, str): if loss in {'ce', 'crossentropy'}: loss = binary_crossentropy if num_classes == 1 else categorical_crossentropy elif loss in {'iou', 'jaccard_loss'}: loss = jaccard_loss elif loss in {'dice_loss', 'Dice'}: loss = dice_loss elif loss in {'ce_dice_loss'}: loss = ce_dice_loss elif loss in {'ce_jaccard_loss'}: loss = ce_jaccard_loss elif loss in {'tversky_loss'}: loss = tversky_loss 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 == 'iou': metrics[i] = iou(num_classes) elif metric == 'dice': metrics[i] = dice(num_classes) elif metric == 'pw_precesion': metrics[i] = pw_precesion(num_classes) elif metric == 'pw_prec': # pixelwise metrics[i] = pw_prec(num_classes) elif metric == 'pw_sens': metrics[i] = pw_sens(num_classes) elif metric == 'pw_spec': metrics[i] = pw_spec(num_classes) elif metric == 'pw_recall': metrics[i] = pw_recall(num_classes) else: raise ValueError('metric %s not recognized' % metric) model.compile(optimizer=Adam(lr=lr), loss=loss, metrics=metrics)
def test_on_mask_data(model, devkit_path): print(" [*] Starting Evaluation", flush=True) print(" [**] Reading Data", flush=True) image_fns, gt_fns = examples(devkit_path) predictions = [] gts = [] for x in range(len(image_fns)): img_fn = image_fns[x] gt_fn = gt_fns[x] image = read_image(img_fn) gt = read_groundtruth(gt_fn) gt = (gt == 26).astype(np.float32) gt = aspect_preserving_resize(gt, model.image_size, resize_method=cv2.INTER_NEAREST) image = aspect_preserving_resize(image, model.image_size, resize_method=cv2.INTER_AREA) prediction, _, _ = model(image, scale_image=False) predictions.append(prediction) gts.append(gt) return iou(predictions, gts)
def fit(self, X, y, step, stop_gradients_for_convs=False): feed_dict = { self.X: X, self.y: y, self.is_training: True, self.keep_prob: self.S.keep_prob, self.step: step, self.stop_gradients_for_convs: stop_gradients_for_convs, } ops = [self.train_step, self.loss, self.predictions, self.merged_summary] start = timer() (_, loss, predictions, summary) = self.session.run(ops, feed_dict) end = timer() accuracy = metrics.accuracy(y, predictions) iou = metrics.iou(y, predictions, self.S.num_classes) if step % 10 == 0: logging.info("fit took %.6f sec" % (end - start, )) self.summary_writer.add_summary(summary, step) return (loss, predictions, accuracy, iou)
vertices = cv2.approxPolyDP(contour, epsilon, True) vertices = cv2.convexHull(vertices, clockwise=True) cv2.fillPoly(predicted_mask, [vertices], 1) predictions.append(predicted_mask) gts.append(gt) results[y1:y2, x1:x2] = np.logical_or(results[y1:y2, x1:x2], predicted_mask.astype(np.bool)) gt_masks[y1:y2, x1:x2] = np.logical_or(gt_masks[y1:y2, x1:x2], gt.astype(np.bool)) c = np.array([220.0, 50.0, 50.0]) results = results.astype(np.float) colored_mask = (np.expand_dims(results, axis=-1) * c).astype(np.uint8) masked_image = cv2.addWeighted(image, 1.0, colored_mask, .8, gamma=0.0) masked_image = Image.fromarray(masked_image) masked_image.save( os.path.join("coco_results", str(counter) + "mask.png")) gt_masks = gt_masks.astype(np.float) colored_mask = (np.expand_dims(gt_masks, axis=-1) * c).astype(np.uint8) masked_image = cv2.addWeighted(image, 1.0, colored_mask, .8, gamma=0.0) masked_image = Image.fromarray(masked_image) masked_image.save(os.path.join("coco_results", str(counter) + "gt.png")) counter += 1 print(iou(predictions, gts))
def run_test(weights='weights/yolo.h5', trt_engine='weights/engines/model_trained_yolo.fp16.engine', iou_threshold=0.5, confidence_threshold=0.8, trt=False, show=True): if trt: engine = load_engine(trt_engine) inputs, outputs, bindings, stream = allocate_buffers(engine) context = engine.create_execution_context() else: # create the model model = yolo_model() model.load_weights(weights) # model.summary() # test list_test_images = load_test_images() test_set_size = len(list_test_images) print('Test_set_size : ', test_set_size) iou_list = [] pr_list = [] gt_list = [] for i in range(test_set_size): print(i) image_name = list_test_images[i] preprocess = get_test_image(image_name) np.copyto(inputs[0].host, preprocess.ravel()) if trt: yolo_out = np.array([ do_inference(context, bindings=bindings, inputs=inputs, outputs=outputs, stream=stream) ]).reshape((1, 7, 7, 5)) yolo_output = yolo_out[0] else: yolo_output = model.predict(preprocess)[0] pr_bbox = convert_anchor_to_bbox(yolo_output, threshold=confidence_threshold, width=f.target_size, height=f.target_size) gt_bbox = get_test_bbox(image_name) if gt_bbox is None and pr_bbox is None: pr_list.append(0) gt_list.append(0) tmp_iou = -1 elif gt_bbox is None and pr_bbox is not None: pr_list.append(1) gt_list.append(0) iou_list.append(0) tmp_iou = 0 elif gt_bbox is not None and pr_bbox is None: pr_list.append(0) gt_list.append(1) iou_list.append(0) tmp_iou = 0 elif gt_bbox is not None and pr_bbox is not None: gt_list.append(1) tmp_iou = iou(gt_bbox, pr_bbox) if tmp_iou > iou_threshold: pr_list.append(1) else: pr_list.append(0) iou_list.append(tmp_iou) #if show: # show_result(preprocess[0], pr_bbox, gt_bbox, tmp_iou) # if cv2.waitKey(60) & 0xff == 27: # cv2.destroyAllWindows() # break avg_iou = sum(iou_list) / len(iou_list) acc, recall, precision, _ = get_stat(gt_list, pr_list) print('Avg iou : {:.2f}'.format(avg_iou * 100)) print('Accuracy : {:.2f} %'.format(acc * 100)) print('Recall : {:.2f} %'.format(recall * 100)) print('Precision : {:.2f} %'.format(precision * 100))
def train( epochs: int, models_dir: Path, x_cities: List[CityData], y_city: List[CityData], mask_dir: Path, ): model = UNet11().cuda() optimizer = Adam(model.parameters(), lr=3e-4) scheduler = ReduceLROnPlateau(optimizer, patience=4, factor=0.25) min_loss = sys.maxsize criterion = nn.BCEWithLogitsLoss() train_data = DataLoader(TrainDataset(x_cities, mask_dir), batch_size=4, num_workers=4, shuffle=True) test_data = DataLoader(TestDataset(y_city, mask_dir), batch_size=6, num_workers=4) for epoch in range(epochs): print(f'Epoch {epoch}, lr {optimizer.param_groups[0]["lr"]}') print(f" Training") losses = [] ious = [] jaccs = [] batch_iterator = enumerate(train_data) model = model.train().cuda() for i, (x, y) in tqdm(batch_iterator): optimizer.zero_grad() x = x.cuda() y = y.cuda() y_real = y.view(-1).float() y_pred = model(x) y_pred_probs = torch.sigmoid(y_pred).view(-1) loss = 0.75 * criterion(y_pred.view( -1), y_real) + 0.25 * dice_loss(y_pred_probs, y_real) iou_ = iou(y_pred_probs.float(), y_real.byte()) jacc_ = jaccard(y_pred_probs.float(), y_real) ious.append(iou_.item()) losses.append(loss.item()) jaccs.append(jacc_.item()) loss.backward() optimizer.step() print( f"Loss: {np.mean(losses)}, IOU: {np.mean(ious)}, jacc: {np.mean(jaccs)}" ) model = model.eval().cuda() losses = [] ious = [] jaccs = [] with torch.no_grad(): batch_iterator = enumerate(test_data) for i, (x, y) in tqdm(batch_iterator): x = x.cuda() y = y.cuda() y_real = y.view(-1).float() y_pred = model(x) y_pred_probs = torch.sigmoid(y_pred).view(-1) loss = 0.75 * criterion(y_pred.view( -1), y_real) + 0.25 * dice_loss(y_pred_probs, y_real) iou_ = iou(y_pred_probs.float(), y_real.byte()) jacc_ = jaccard(y_pred_probs.float(), y_real) ious.append(iou_.item()) losses.append(loss.item()) jaccs.append(jacc_.item()) test_loss = np.mean(losses) print( f"Loss: {np.mean(losses)}, IOU: {np.mean(ious)}, jacc: {np.mean(jaccs)}" ) scheduler.step(test_loss) if test_loss < min_loss: min_loss = test_loss save_model(model, epoch, models_dir / y_city[0].name)