def plotKeypointsOverOutputModel(index, dataset, model, img_folder): """Forward a img to the model and display the output keypoints over the image. It enables us to see the loss evolution over the model visually over the image index is the index of the img in the dataset argument""" # Get an image imgId = dataset.img_ids[index] img, keypoints = dataset[index] # Transform into a pytorch model input and Forward pass y = model(Variable(img.unsqueeze(0))) # Get the coordinates of the keypoints keypoints = keypoints_from_heatmaps(y[0].data.numpy()) # Plot the image img_anno = dataset.annotations.loadImgs(imgId)[0] img_path = os.path.join(img_folder, img_anno['file_name']) img_array = load_image(img_path) img_array_resized = resize(img_array, (512, 640)) plt.figure() plt.title('Original image') plt.imshow(img_array_resized) xs, ys, vs = get_xs_ys_vs(keypoints) plt.plot(xs, ys, 'ro', color='c') plt.show()
def test(images, threshold, img_s, context): print("Loading model...") model = load_model("model/global-wheat-yolo3-darknet53.params", ctx=context) for path in images: print(path) raw = load_image(path) rh, rw, _ = raw.shape classes_list = [] scores_list = [] bboxes_list = [] for _ in range(5): img, flips = gcv.data.transforms.image.random_flip(raw, px=0.5, py=0.5) x, _ = gcv.data.transforms.presets.yolo.transform_test(img, short=img_s) _, _, xh, xw = x.shape rot = random.randint(0, 3) if rot > 0: x = np.rot90(x.asnumpy(), k=rot, axes=(2, 3)) classes, scores, bboxes = model(mx.nd.array(x, ctx=context)) if rot > 0: if rot == 1: raw_bboxes = bboxes.copy() bboxes[0, :, [0, 2]] = xh - raw_bboxes[0, :, [1, 3]] bboxes[0, :, [1, 3]] = raw_bboxes[0, :, [2, 0]] elif rot == 2: bboxes[0, :, [0, 1, 2, 3]] = mx.nd.array([[xw], [xh], [xw], [xh]], ctx=context) - bboxes[0, :, [2, 3, 0, 1]] elif rot == 3: raw_bboxes = bboxes.copy() bboxes[0, :, [0, 2]] = raw_bboxes[0, :, [1, 3]] bboxes[0, :, [1, 3]] = xw - raw_bboxes[0, :, [2, 0]] raw_bboxes = bboxes.copy() bboxes[0, :, 0] = raw_bboxes[0, :, [0, 2]].min(axis=0) bboxes[0, :, 1] = raw_bboxes[0, :, [1, 3]].min(axis=0) bboxes[0, :, 2] = raw_bboxes[0, :, [0, 2]].max(axis=0) bboxes[0, :, 3] = raw_bboxes[0, :, [1, 3]].max(axis=0) bboxes[0, :, :] = gcv.data.transforms.bbox.flip(bboxes[0, :, :], (xw, xh), flip_x=flips[0], flip_y=flips[1]) bboxes[0, :, 0::2] = (bboxes[0, :, 0::2] / (xw - 1)).clip(0.0, 1.0) bboxes[0, :, 1::2] = (bboxes[0, :, 1::2] / (xh - 1)).clip(0.0, 1.0) classes_list.append([ int(classes[0, i].asscalar()) for i in range(classes.shape[1]) if classes[0, i].asscalar() >= 0.0 ]) scores_list.append([ scores[0, i].asscalar() for i in range(classes.shape[1]) if classes[0, i].asscalar() >= 0.0 ]) bboxes_list.append([ bboxes[0, i].asnumpy().tolist() for i in range(classes.shape[1]) if classes[0, i].asscalar() >= 0.0 ]) bboxes, scores, classes = weighted_boxes_fusion(bboxes_list, scores_list, classes_list) bboxes[:, 0::2] *= rw - 1 bboxes[:, 1::2] *= rh - 1 gcv.utils.viz.plot_bbox(raw, [ bboxes[i] for i in range(classes.shape[0]) if model.classes[int(classes[i])] == "wheat" and scores[i] > threshold ]) plt.show()
def evaluate_coco(model, dataset, coco, eval_type="bbox", limit=0, image_ids=None): """Runs official COCO evaluation. dataset: A Dataset object with valiadtion data eval_type: "bbox" or "segm" for bounding box or segmentation evaluation limit: if not 0, it's the number of images to use for evaluation """ # Pick COCO images from the dataset image_ids = image_ids or dataset.image_ids # Limit to a subset if limit: image_ids = image_ids[:limit] # Get corresponding COCO image IDs. coco_image_ids = [dataset.image_info[id]["id"] for id in image_ids] t_prediction = 0 t_start = time.time() results = [] for i, image_id in enumerate(image_ids): # Load image image = dataset.load_image(image_id) # Run detection t = time.time() r = model.detect([image], verbose=0)[0] t_prediction += (time.time() - t) # Convert results to COCO format # Cast masks to uint8 because COCO tools errors out on bool image_results = build_coco_results(dataset, coco_image_ids[i:i + 1], r["rois"], r["class_ids"], r["scores"], r["masks"].astype(np.uint8)) results.extend(image_results) # Load results. This modifies results with additional attributes. coco_results = coco.loadRes(results) # Evaluate cocoEval = COCOeval(coco, coco_results, eval_type) cocoEval.params.imgIds = coco_image_ids cocoEval.evaluate() cocoEval.accumulate() cocoEval.summarize() print("Prediction time: {}. Average {}/image".format( t_prediction, t_prediction / len(image_ids))) print("Total time: ", time.time() - t_start)
def load_and_process_image(self, path, imggen=None): """ Load and preprocess a single image Args: path: path to image file. imggen: Image Generator for performing image perturbation Returns: image in ndarray """ img = dataset.load_image(path, self.img_grayscale) if self.img_resized: img = dataset.resize_img(img, self.img_size) if imggen: img = imggen.random_transform(img) return img
def generator(self, n=0): i = 0 name = None if n == 0: n = self.n while i < n: img_path = self.img_paths[i] if self.mode != 'test': label_val = int(self.label[i]) label = np.array(onehot(label_val, self.num)) else: label = self.label img = load_image(img_path) ori_img = resize_image(img, (self.width, self.height)) img = np.float32(ori_img) / 255.0 if self.mode == 'train': #flip image #rotate image in range of [-30, 30] if random.random() < cfg.p_rotate: img_rotate = rotate(img, self.width, self.height) yield img_rotate, label # # hsv image # if random.random() < cfg.p_hsv: # img_hsv = random_hsv_transform(ori_img) # img_hsv = np.float32(img_hsv) / 255.0 # yield img_hsv, label # # # #gamma # if random.random() < cfg.p_gamma: # img_gamma = random_gamma_transform(ori_img) # img_gamma = np.float32(img_gamma) / 255.0 # yield img_gamma, label if self.mode == 'test': yield img_path, img else: yield img, label i += 1
def predict(myFile): # First, pass the path of the image dir_path = os.path.dirname(os.path.realpath(__file__)) image_path = myFile filename = str(dir_path + '/' + image_path) image_size = 8 num_channels = 6 images = [] # Reading the image using OpenCV image = dataset.load_image(filename) # Resizing the image to our desired size and preprocessing will be done exactly as done during training x_batch = [image] ## Let us restore the saved model sess = tf.Session() # Step-1: Recreate the network graph. At this step only graph is created. saver = tf.train.import_meta_graph('eval-model.meta') # Step-2: Now let's load the weights saved using the restore method. saver.restore(sess, tf.train.latest_checkpoint('./')) # Accessing the default graph which we have restored graph = tf.get_default_graph() # Now, let's get hold of the op that we can be processed to get the output. # In the original network y_pred is the tensor that is the prediction of the network y_pred = graph.get_tensor_by_name("y_pred:0") ## Let's feed the images to the input placeholders x = graph.get_tensor_by_name("x:0") y_true = graph.get_tensor_by_name("y_true:0") y_test_images = np.zeros((1, len(os.listdir('training_data')))) ### Creating the feed_dict that is required to be fed to calculate y_pred feed_dict_testing = {x: x_batch, y_true: y_test_images} result = sess.run(y_pred, feed_dict=feed_dict_testing) # result is of this format [probabiliy_of_rose probability_of_sunflower] #print(sess.run(tf.argmax(y_pred, 1), feed_dict={x: mnist.test.images})) """ builder = tf.saved_model.builder.SavedModelBuilder("/Users/thomas/Personal-Projects/chess/evaluation/pos-model" ) builder.add_meta_graph_and_variables( sess, [tf.saved_model.tag_constants.SERVING] ) builder.save() """ return result
def test(images, model, is_reversed, size, context): print("Loading models...", flush=True) dis_a = PatchDiscriminator() dis_a.load_parameters("model/{}.dis_a.params".format(model), ctx=context) dis_b = PatchDiscriminator() dis_b.load_parameters("model/{}.dis_b.params".format(model), ctx=context) gen_ab = ResnetGenerator() gen_ab.load_parameters("model/{}.gen_ab.params".format(model), ctx=context) gen_ba = ResnetGenerator() gen_ba.load_parameters("model/{}.gen_ba.params".format(model), ctx=context) for path in images: print(path) raw = load_image(path) real = mx.image.resize_short(raw, size) real = mx.nd.image.normalize(mx.nd.image.to_tensor(real), mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5)) real = real.expand_dims(0).as_in_context(context) real_a_y, _ = dis_a(real) real_b_y, _ = dis_b(real) if is_reversed: fake, _ = gen_ba(real) rec, _ = gen_ab(fake) else: fake, _ = gen_ab(real) rec, _ = gen_ba(fake) fake_a_y, _ = dis_a(fake) fake_b_y, _ = dis_b(fake) print("Real score A:", mx.nd.sigmoid(real_a_y).mean().asscalar()) print("Real score B:", mx.nd.sigmoid(real_b_y).mean().asscalar()) print("Fake score A:", mx.nd.sigmoid(fake_a_y).mean().asscalar()) print("Fake score B:", mx.nd.sigmoid(fake_b_y).mean().asscalar()) plt.subplot(1, 3, 1) plt.imshow(raw.asnumpy()) plt.axis("off") plt.subplot(1, 3, 2) plt.imshow(reconstruct_color(fake[0].transpose((1, 2, 0))).asnumpy()) plt.axis("off") plt.subplot(1, 3, 3) plt.imshow(reconstruct_color(rec[0].transpose((1, 2, 0))).asnumpy()) plt.axis("off") plt.show()
def predict(): # Equivalent to shuffling for test in test_input_names: # to get the right aspect ratio of the output loaded_image = dataset.load_image(test) height, width, channels = loaded_image.shape resize_height = int(height / (width / cfg.width)) resized_image = cv2.resize(loaded_image, (cfg.width, resize_height)) input_image = np.expand_dims( np.float32(resized_image[:cfg.height, :cfg.width]), axis=0) / 255.0 st = time.time() print(input_image.shape) output_image = sess.run(network, feed_dict={net_input: input_image}) run_time = time.time() - st output_image = np.array(output_image[0, :, :, :]) output_image = helpers.reverse_one_hot(output_image) # this needs to get generalized # class_names_list, label_values = helpers.get_label_info(os.path.join(cfg.data_dir, "class_dict.csv")) out_vis_image = helpers.colour_code_segmentation( output_image, label_values) # print(out_vis_image.shape) # out_vis_image = cv2.resize(out_vis_image, (height, width)) # out_vis_image[out_vis_image >= cfg.threshold*255] = 255 # out_vis_image[out_vis_image < cfg.threshold*255] = 0 # # save_img = cv2.cvtColor(np.uint8(loaded_image), cv2.COLOR_RGB2BGR) # transparent_image = np.append(np.array(save_img)[:, :, 0:3], out_vis_image[:, :, None], axis=-1) # transparent_image = Image.fromarray(transparent_image) file_name = utils.filepath_to_name(test) cv2.imwrite( cfg.base_dir + "%s/%s/%s_pred.png" % ("result", "test", file_name), cv2.cvtColor(np.uint8(out_vis_image), cv2.COLOR_RGB2BGR)) # cv2.imwrite(cfg.base_dir + "%s/%s/%s_pred.png" % ("result", "Test", file_name), transparent_image) print("Finished!")
def bounding_boxes(): test_path = 'input/test_stg2/' model_x = load_model('fisheries-localization-x.h5') model_y = load_model('fisheries-localization-y.h5') files = os.listdir(test_path) for filename in files: file_path = test_path + filename img = io.imread(file_path) X = dataset.load_image(file_path) pred_x = model_x.predict(X) pred_y = model_y.predict(X) print(str(pred_x) + ',' + str(pred_y)) plt.imshow(img) plt.gca().add_patch(pts.Circle((pred_x[0, 0], pred_y[0, 0]), 50)) plt.gca().add_patch( pts.Rectangle((pred_x[0, 0], pred_y[0, 0]), 300, 300, fill=None)) plt.show()
def visualize(): model = load_model('fisheries.h5') path = './input/train/ALB/img_00003.jpg' img = utils.load_img(path, target_size=(dataset.SIZE, dataset.SIZE)) X = dataset.load_image(path) print(X.shape) # print(X[0]) preds = model.predict(X) pred_class = preds.argmax() print('Predicted:' + str(preds)) print('Predicted:' + dataset.TYPES[pred_class]) plt.imshow(img) plt.show() idx = [2, 6, 8, 13] for i in idx: print(model.layers[i]) heatmap = visualize_cam(model, i, [pred_class], img) plt.imshow(heatmap) plt.show()
def get_seed_image(bpart, img_size, img_path, grayscale): """ Utility method for getting a seeding image to visualize attention. Pick a random image from validation set, unless img_path is specified. :param bpart: Body part to pick. :param img_size: Image size to reshape to. :param img_path: path to image file. :param grayscale: Import image as grayscale or RGB :return: Keras model """ _, valid_labeled, _, valid_path = dataset.load_dataframe() if not img_path: df_valid = dataset.build_dataframe(valid_labeled, valid_path) if bpart != "all": df_valid = df_valid[df_valid["body_part"] == bpart] rdm_row = df_valid.sample(1).iloc[0] img_path = rdm_row["path"] label = rdm_row["label"] else: label = valid_labeled[valid_labeled["path"] == img_path].iloc[0]["label"] img = dataset.load_image(img_path, grayscale) img = dataset.resize_img(img, img_size) return img, img_path, label
def test(images, dims, threshold, plt_hw, seq_len, no_yolo, beam, beam_size, context): print("Loading model...") if not no_yolo: yolo = model_zoo.get_model('yolo3_darknet53_voc', pretrained=True, ctx=context) wpod = WpodNet() wpod.load_parameters("model/wpod_net.params", ctx=context) vocab = Vocabulary() vocab.load("model/vocabulary.json") ocr = OcrNet(plt_hw, vocab.size(), seq_len) ocr.load_parameters("model/ocr_net.params", ctx=context) for path in images: print(path) raw = load_image(path) if no_yolo: detect_plate(wpod, vocab, ocr, raw, dims, threshold, plt_hw, beam, beam_size, context) else: ts = time.time() x, _ = data.transforms.presets.yolo.transform_test(raw, short=512) classes, scores, bboxes = yolo(x.as_in_context(context)) bboxes[0, :, 0::2] = bboxes[0, :, 0::2] / x.shape[3] * raw.shape[1] bboxes[0, :, 1::2] = bboxes[0, :, 1::2] / x.shape[2] * raw.shape[0] vehicles = [ fixed_crop(raw, bboxes[0, i]) for i in range(classes.shape[1]) if (yolo.classes[int(classes[0, i].asscalar())] == 'car' or yolo.classes[int(classes[0, i].asscalar())] == 'bus') and scores[0, i].asscalar() > 0.5 ] print("yolo profiling: %f" % (time.time() - ts)) for i, raw in enumerate(vehicles): print("vehicle[%d]:" % i) detect_plate(wpod, vocab, ocr, raw, dims, threshold, plt_hw, beam, beam_size, context)
""" mask = np.dstack((mask, mask, mask)) * np.array(color) mask = mask.astype(np.uint8) weighted_sum = cv2.addWeighted(mask, 0.5, image, 0.5, 0.) img = image.copy() ind = mask[:, :, 1] > 0 img[ind] = weighted_sum[ind] return img #%% model_path = 'unet16_binary_20/model_0.pt' model = get_model(model_path, model_type='UNet16', problem_type='binary') #%% img_file_name = '3064_img.jpg' img= load_image(img_file_name) imshow(img) #%% img_transform = Compose([ ToTensor(), Normalize(mean=[0.1509,0.1509,0.1509], std=[0.0612,0.0612,0.0612]) ]) #%% temp = variable(img_transform(img)) input_img = torch.unsqueeze(temp, dim=0) #%%
def train(): if cfg.class_balancing: print("Computing class weights for trainlabel ...") class_weights = utils.compute_class_weights( labels_dir=train_output_names, label_values=label_values) weights = tf.reduce_sum(class_weights * net_output, axis=-1) unweighted_loss = None unweighted_loss = tf.nn.softmax_cross_entropy_with_logits_v2( logits=network, labels=net_output) losses = unweighted_loss * class_weights else: losses = tf.nn.softmax_cross_entropy_with_logits_v2(logits=network, labels=net_output) loss = tf.reduce_mean(losses) opt = tf.train.AdamOptimizer(cfg.lr).minimize( loss, var_list=[var for var in tf.trainable_variables()]) sess.run(tf.global_variables_initializer()) utils.count_params() # If a pre-trained ResNet is required, load the weights. # This must be done AFTER the variables are initialized with sess.run(tf.global_variables_initializer()) if init_fn is not None: init_fn(sess) avg_scores_per_epoch = [] avg_loss_per_epoch = [] # Which validation images do we want val_indices = [] num_vals = min(cfg.num_val_images, len(val_input_names)) # Set random seed to make sure models are validated on the same validation images. # So you can compare the results of different models more intuitively. random.seed(16) val_indices = random.sample(range(0, len(val_input_names)), num_vals) # Do the training here for epoch in range(0, cfg.num_epochs): current_losses = [] cnt = 0 # Equivalent to shuffling id_list = np.random.permutation(len(train_input_names)) num_iters = int(np.floor(len(id_list) / cfg.batch_size)) st = time.time() epoch_st = time.time() for i in range(num_iters): # st=time.time() input_image_batch = [] output_image_batch = [] # Collect a batch of images for j in range(cfg.batch_size): index = i * cfg.batch_size + j id = id_list[index] input_image = dataset.load_image(train_input_names[id]) output_image = dataset.load_image(train_output_names[id]) h, w, _ = input_image.shape new_h, new_w = dataset.getTrainSize(h, w) with tf.device('/cpu:0'): input_image, output_image = dataset.data_augmentation( input_image, output_image, new_h, new_w) # Prep the data. Make sure the labels are in one-hot format input_image = np.float32(input_image) / 255.0 output_image = np.float32( helpers.one_hot_it(label=output_image, label_values=label_values)) input_image_batch.append( np.expand_dims(input_image, axis=0)) output_image_batch.append( np.expand_dims(output_image, axis=0)) # ***** THIS CAUSES A MEMORY LEAK AS NEW TENSORS KEEP GETTING CREATED ***** # input_image = tf.image.crop_to_bounding_box(input_image, offset_height=0, offset_width=0, # target_height=args.crop_height, target_width=args.crop_width).eval(session=sess) # output_image = tf.image.crop_to_bounding_box(output_image, offset_height=0, offset_width=0, # target_height=args.crop_height, target_width=args.crop_width).eval(session=sess) # ***** THIS CAUSES A MEMORY LEAK AS NEW TENSORS KEEP GETTING CREATED ***** # memory() # print(cfg.batch_size) if cfg.batch_size == 1: input_image_batch = input_image_batch[0] output_image_batch = output_image_batch[0] else: input_image_batch = np.squeeze( np.stack(input_image_batch, axis=1)) output_image_batch = np.squeeze( np.stack(output_image_batch, axis=1)) # print(input_image_batch.shape) # Do the training _, current = sess.run([opt, loss], feed_dict={ net_input: input_image_batch, net_output: output_image_batch }) current_losses.append(current) cnt = cnt + cfg.batch_size if cnt % 20 == 0: string_print = "Epoch = %d Count = %d Current_Loss = %.4f Time = %.2f" % ( epoch, cnt, current, time.time() - st) utils.LOG(string_print) st = time.time() mean_loss = np.mean(current_losses) avg_loss_per_epoch.append(mean_loss) # Create directories if needed if not os.path.isdir(cfg.base_dir + "%s/%s/%04d" % ("checkpoints", cfg.model, epoch)): os.makedirs(cfg.base_dir + "%s/%s/%04d" % ("checkpoints", cfg.model, epoch)) # Save latest checkpoint to same file name print("Saving latest checkpoint") saver.save(sess, model_checkpoint_name) if val_indices != 0 and epoch % cfg.checkpoint_step == 0: print("Saving checkpoint for this epoch") saver.save( sess, cfg.base_dir + "%s/%s/%04d/model.ckpt" % ("checkpoints", cfg.model, epoch)) if epoch % cfg.validation_step == 0: print("Performing validation") target = open( cfg.base_dir + "%s/%s/%04d/val_scores.csv" % ("checkpoints", cfg.model, epoch), 'w') target.write( "val_name, avg_accuracy, precision, recall, f1 score, mean iou, %s\n" % (class_names_string)) scores_list = [] class_scores_list = [] precision_list = [] recall_list = [] f1_list = [] iou_list = [] # Do the validation on a small set of validation images for ind in val_indices: input_image = dataset.load_image(val_input_names[ind]) output_image = dataset.load_image(val_output_names[ind]) h, w, _ = input_image.shape new_h, new_w = dataset.getTrainSize(h, w) input_image, output_image = utils.random_crop( input_image, output_image, new_h, new_w) input_image = np.expand_dims(np.float32(input_image), axis=0) / 255.0 gt = helpers.reverse_one_hot( helpers.one_hot_it(output_image, label_values)) # st = time.time() output_image = sess.run(network, feed_dict={net_input: input_image}) output_image = np.array(output_image[0, :, :, :]) output_image = helpers.reverse_one_hot(output_image) out_vis_image = helpers.colour_code_segmentation( output_image, label_values) accuracy, class_accuracies, prec, rec, f1, iou = utils.evaluate_segmentation( pred=output_image, label=gt, num_classes=num_classes) file_name = utils.filepath_to_name(val_input_names[ind]) target.write("%s, %f, %f, %f, %f, %f" % (file_name, accuracy, prec, rec, f1, iou)) for item in class_accuracies: target.write(", %f" % (item)) target.write("\n") scores_list.append(accuracy) class_scores_list.append(class_accuracies) precision_list.append(prec) recall_list.append(rec) f1_list.append(f1) iou_list.append(iou) gt = helpers.colour_code_segmentation(gt, label_values) file_name = os.path.basename(val_input_names[ind]) file_name = os.path.splitext(file_name)[0] cv2.imwrite( cfg.base_dir + "%s/%s/%04d/%s_pred.png" % ("checkpoints", cfg.model, epoch, file_name), cv2.cvtColor(np.uint8(out_vis_image), cv2.COLOR_RGB2BGR)) cv2.imwrite( cfg.base_dir + "%s/%s/%04d/%s_gt.png" % ("checkpoints", cfg.model, epoch, file_name), cv2.cvtColor(np.uint8(gt), cv2.COLOR_RGB2BGR)) target.close() avg_score = np.mean(scores_list) class_avg_scores = np.mean(class_scores_list, axis=0) avg_scores_per_epoch.append(avg_score) avg_precision = np.mean(precision_list) avg_recall = np.mean(recall_list) avg_f1 = np.mean(f1_list) avg_iou = np.mean(iou_list) print("\nAverage validation accuracy for epoch # %04d = %f" % (epoch, avg_score)) print("Average per class validation accuracies for epoch # %04d:" % (epoch)) for index, item in enumerate(class_avg_scores): print("%s = %f" % (class_names_list[index], item)) print("Validation precision = ", avg_precision) print("Validation recall = ", avg_recall) print("Validation F1 score = ", avg_f1) print("Validation IoU score = ", avg_iou) epoch_time = time.time() - epoch_st remain_time = epoch_time * (cfg.num_epochs - 1 - epoch) m, s = divmod(remain_time, 60) h, m = divmod(m, 60) if s != 0: train_time = "Remaining training time = %d hours %d minutes %d seconds\n" % ( h, m, s) else: train_time = "Remaining training time : Training completed.\n" utils.LOG(train_time) scores_list = [] utils.drawLine(range(cfg.num_epochs), avg_scores_per_epoch, cfg.base_dir + 'checkpoints/' + cfg.model + '/accuracy_vs_epochs.png', title='Average validation accuracy vs epochs', xlabel='Epoch', ylabel='Avg. val. accuracy') utils.drawLine(range(cfg.num_epochs), avg_loss_per_epoch, cfg.base_dir + 'checkpoints/' + cfg.model + '/loss_vs_epochs.png', title='Average loss vs epochs', xlabel='Epoch', ylabel='Current loss')
import numpy as np import matplotlib.pyplot as plt from albumentations.pytorch.transforms import img_to_tensor arrt = np.random.randn(500, 500) tensor = img_to_tensor(arrt) mean=(0.485, 0.456, 0.406) std=(0.229, 0.224, 0.225) #new_img = img - mean /std #old img = model_path = 'pretrained/unet16_instruments_20/model_1.pt' model = get_model(model_path, model_type='UNet16', problem_type='instruments') img_l = load_image('dataset/instrument_dataset_1/left_frames/frame000.png') input_img_l = torch.unsqueeze(img_to_tensor(img_transform(p=1)(image=img_l)['image']), dim=0) mask_l = model(input_img_l) img_r = load_image('dataset/instrument_dataset_1/right_frames/frame000.png') input_img_r = torch.unsqueeze(img_to_tensor(img_transform(p=1)(image=img_r)['image']), dim=0) mask_r = model(input_img_r) mask = jaccard(mask_l, mask_r) im_seg = mask.data[0].cpu().numpy()[0] #mask_array = (im_seg * std) + mean plt.imshow(im_seg > 0)
def main(args): dataset_path = './BDCI2017-jiage-Semi' model_path='./model' model_name='FPN_ResNet_itr100000' model_file = os.path.join(model_path,'%s.ckpt'%model_name) period = 'test' csv_path = './CSV' class_num = 5 sample_num = 3 patch_size=256 sample_size = 1024 rate = sample_size/patch_size batch_size=1 accuracy = 0 radius = 8 eps = 0.2*0.2 os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu file_path = os.path.join(dataset_path,'test') print('NO.1 test sample is loading...') image = dataset.load_image(file_path,index=1,load_label=False) ori_row = image.shape[0] ori_col = image.shape[1] image = cv2.resize(image,(np.int32(image.shape[1]/rate),np.int32(image.shape[0]/rate))) print('loading finished') row = image.shape[0] col = image.shape[1] x = tf.placeholder(tf.float32,[batch_size,patch_size,patch_size,3]) net = factory.FPN_ResNet(x,class_num) net_sub = tf.slice(net,[0,0,0,1],[1,256,256,4]) #CRF net_softmax = tf.nn.softmax(net_sub)#########attention net not net_sub x_int = (1+x)*128 x_int = tf.cast(x_int,dtype=tf.uint8) result = tf.py_func(utils.dense_crf, [net_softmax, x_int], tf.float32) # result = tf.argmax(result,axis=-1) sess = tf.Session() sess.run(tf.global_variables_initializer()) saver = tf.train.Saver() print('start restore parameter...') saver.restore(sess,model_file) print('parameter restore finished!') offs=int(patch_size/4) offe=int(3*patch_size/4) for n in range(1,sample_num+1): if n!=1: print('NO.%d test sample is loading...'%n) image = dataset.load_image(file_path,index=n,load_label=False) ori_row = image.shape[0] ori_col = image.shape[1] image = cv2.resize(image,(np.int32(image.shape[1]/rate),np.int32(image.shape[0]/rate))) row = image.shape[0] col = image.shape[1] print('loading finished') print('float transforming...') image = np.float32(image)/128.0-1.0 vote = np.zeros((row,col,class_num-1))#original class_num-1 sub_image = image[0:patch_size,0:patch_size,:] sub_image = np.reshape(sub_image,[1,patch_size,patch_size,3]) cls_result = sess.run(result,feed_dict={x:sub_image}) vote[0:offe,0:offe]\ = cls_result[0,0:offe,0:offe] for c in range(0,col-patch_size,int(patch_size/2)): sub_image = image[0:patch_size,c:c+patch_size,:] sub_image = np.reshape(sub_image,[1,patch_size,patch_size,3]) cls_result = sess.run(result,feed_dict={x:sub_image}) vote[0:offe,c+offs:c+offe] \ = cls_result[0,0:offe,offs:offe] sub_image = image[0:patch_size,col-patch_size:col,:] sub_image = np.reshape(sub_image,[1,patch_size,patch_size,3]) cls_result = sess.run(result,feed_dict={x:sub_image}) vote[0:offe,col-patch_size+offs:col]\ = cls_result[0,0:offe,offs:] for r in range(0,row-patch_size,int(patch_size/2)): print('sample%d,row:%d patch is processing'%(n,r)) sub_image = image[r:r+patch_size,0:patch_size,:] sub_image = np.reshape(sub_image,[1,patch_size,patch_size,3]) cls_result = sess.run(result,feed_dict={x:sub_image}) vote[r+offs:r+offe,0:offe] \ = cls_result[0,offs:offe,0:offe] for c in range(0,col-patch_size,int(patch_size/2)): sub_image = image[r:r+patch_size,c:c+patch_size,:] sub_image = np.reshape(sub_image,[1,patch_size,patch_size,3]) cls_result = sess.run(result,feed_dict={x:sub_image}) vote[r+offs:r+offe,c+offs:c+offe]\ = cls_result[0,offs:offe,offs:offe] sub_image = image[r:r+patch_size,col-patch_size:col,:] sub_image = np.reshape(sub_image,[1,patch_size,patch_size,3]) cls_result = sess.run(result,feed_dict={x:sub_image}) vote[r+offs:r+offe,col-patch_size+offs:col] \ = cls_result[0,offs:offe,offs:patch_size] sub_image = image[row-patch_size:row,0:patch_size,:] sub_image = np.reshape(sub_image,[1,patch_size,patch_size,3]) cls_result = sess.run(result,feed_dict={x:sub_image}) vote[row-patch_size+offs:row,0:offe]\ = cls_result[0,offs:,0:offe] for c in range(0,col-patch_size,int(patch_size/2)): sub_image = image[row-patch_size:row,c:c+patch_size,:] sub_image = np.reshape(sub_image,[1,patch_size,patch_size,3]) cls_result = sess.run(result,feed_dict={x:sub_image}) vote[row-patch_size+offs:row,c+offs:c+offe] \ = cls_result[0,offs:patch_size,offs:offe] sub_image = image[row-patch_size:row,col-patch_size:col,:] sub_image = np.reshape(sub_image,[1,patch_size,patch_size,3]) cls_result = sess.run(result,feed_dict={x:sub_image}) vote[row-patch_size+offs:row,col-patch_size+offs:col]\ = cls_result[0,offs:,offs:] # gray_img = cv2.cvtColor(image,cv2.COLOR_RGB2GRAY) # for channel in range(0,class_num-1): # temp_vote = vote[:,:,channel] # vote[:,:,channel] = guidedfilter.guidedfilter(temp_vote,gray_img,radius,eps) # vote_softmax = vote.copy() # vote_softmax = vote_softmax[:,:,[1,3]] # vote_pb = np.argmax(vote_softmax,axis=-1) # vote_pb[vote_pb==1]=3 # vote_pb[vote_pb==0]=1 vote = np.argmax(vote,axis=-1) vote = np.uint8(vote) # vote[vote==0]=vote_pb[vote==0] # vote = cv2.medianBlur(vote,7) vote = vote+1 copy_vote = vote.copy() copy_vote[vote==2] = 4 copy_vote[vote==3] = 2 copy_vote[vote==4] = 3 vote = copy_vote.copy() vote = cv2.resize(vote,(ori_col,ori_row),cv2.INTER_NEAREST) print('%d test sample is writing into csv...'%n) write_csv(csv_path,index=n,label=vote) print('%d test result is writing into png...'%n) save_y(file_path,n,vote) print('writing finished') print('accuracy: %f'%accuracy)
male_val_loader, EPOCHS) print('\nTRAINING FEMALE MODEL') female_model, _, female_optimizer, female_scheduler = train( 'female', female_model, female_optimizer, female_scheduler, female_train_loader, female_val_loader, EPOCHS) # # Generate Output # In[ ]: test_df = pd.read_csv('test.csv') submission = pd.read_csv('sample_submission.csv') progress = tqdm.tqdm(total=len(test_df), desc='Sample', position=0) for key, row in test_df.iterrows(): img_path = os.path.join('images', row['fileName']) img = load_image(img_path) img = img.unsqueeze(0) img = img.cuda() if not GENDER_SENSITIVE: boneage = mixed_model(img) elif row['male'] == True: boneage = male_model(img) else: boneage = female_model(img) boneage = float(boneage.view(-1).detach().cpu()[0]) submission.loc[submission.fileName == row['fileName'], 'boneage'] = boneage if boneage > 0 else 0 progress.update(1)
def generator(self, n=0): i = 0 if n == 0: n = self.n while i < n: img_path = self.img_paths[i] img = load_image(img_path) h, w, _ = img.shape size = [w, h] ori_img = cv2.resize(img, (self.width, self.height), interpolation=cv2.INTER_NEAREST) if self.mode != 'test': ann_path = self.label_paths[i] ann = load_image(ann_path) ann = cv2.resize(ann, (self.width, self.height), interpolation=cv2.INTER_NEAREST) # img = cv2.copyMakeBorder(img, 0, 512 - h, 0, 512 - w, cv2.BORDER_CONSTANT) # heatmap = cv2.resize(heatmap, (512, 512)) img = np.float32(ori_img) / 255.0 if self.mode == 'train': #flip image if random.random() < cfg.p_flip: img_flip, ann_flip = self.flip(img, ann) ann_flip = np.float32( one_hot_it(label=ann_flip, label_values=self.label_value)) yield img_path, size, img_flip, ann_flip #rotate image in range of [-30, 30] if random.random() < cfg.p_rotate: img_rotate, ann_rotate = self.rotate(img, ann) ann_rotate = np.float32( one_hot_it(label=ann_rotate, label_values=self.label_value)) yield img_path, size, img_rotate, ann_rotate # hsv image if random.random() < cfg.p_hsv: img_hsv = self.random_hsv_transform(ori_img) img_hsv = np.float32(img_hsv) / 255.0 ann_hsv = np.float32( one_hot_it(label=ann, label_values=self.label_value)) yield img_path, size, img_hsv, ann_hsv #gamma if random.random() < cfg.p_gamma: img_gamma = self.random_gamma_transform(ori_img) img_gamma = np.float32(img_gamma) / 255.0 ann_gamma = np.float32( one_hot_it(label=ann, label_values=self.label_value)) yield img_path, size, img_gamma, ann_gamma elif self.mode == 'val': ann_convert = np.float32( one_hot_it(label=ann, label_values=self.label_value)) yield img_path, size, img, ann_convert else: yield img_path, size, img i += 1
def val(): # Create directories if needed if not os.path.isdir(cfg.base_dir + "%s/%s" % ("result", "Val")): os.makedirs(cfg.base_dir + "%s/%s" % ("result", "Val")) target = open(cfg.base_dir + "%s/%s/val_scores.csv" % ("result", "Val"), 'w') target.write( "val_name, avg_accuracy, precision, recall, f1 score, mean iou, %s\n" % (class_names_string)) scores_list = [] class_scores_list = [] precision_list = [] recall_list = [] f1_list = [] iou_list = [] run_times_list = [] # Run testing on ALL test images for ind in range(len(val_input_names)): sys.stdout.write("\rRunning test image %d / %d" % (ind + 1, len(val_input_names))) sys.stdout.flush() input_image = np.expand_dims(np.float32( dataset.load_image(val_input_names[ind])[:cfg.height, :cfg.width]), axis=0) / 255.0 gt = dataset.load_image(val_output_names[ind])[:cfg.height, :cfg.width] gt = helpers.reverse_one_hot(helpers.one_hot_it(gt, label_values)) st = time.time() output_image = sess.run(network, feed_dict={net_input: input_image}) run_times_list.append(time.time() - st) output_image = np.array(output_image[0, :, :, :]) output_image = helpers.reverse_one_hot(output_image) out_vis_image = helpers.colour_code_segmentation( output_image, label_values) accuracy, class_accuracies, prec, rec, f1, iou = utils.evaluate_segmentation( pred=output_image, label=gt, num_classes=num_classes) file_name = utils.filepath_to_name(val_input_names[ind]) target.write("%s, %f, %f, %f, %f, %f" % (file_name, accuracy, prec, rec, f1, iou)) for item in class_accuracies: target.write(", %f" % (item)) target.write("\n") scores_list.append(accuracy) class_scores_list.append(class_accuracies) precision_list.append(prec) recall_list.append(rec) f1_list.append(f1) iou_list.append(iou) gt = helpers.colour_code_segmentation(gt, label_values) cv2.imwrite( cfg.base_dir + "%s/%s/%s_pred.png" % ("result", "Val", file_name), cv2.cvtColor(np.uint8(out_vis_image), cv2.COLOR_RGB2BGR)) cv2.imwrite( cfg.base_dir + "%s/%s/%s_gt.png" % ("result", "Val", file_name), cv2.cvtColor(np.uint8(gt), cv2.COLOR_RGB2BGR)) target.close() avg_score = np.mean(scores_list) class_avg_scores = np.mean(class_scores_list, axis=0) avg_precision = np.mean(precision_list) avg_recall = np.mean(recall_list) avg_f1 = np.mean(f1_list) avg_iou = np.mean(iou_list) avg_time = np.mean(run_times_list) print("Average test accuracy = ", avg_score) print("Average per class test accuracies = \n") for index, item in enumerate(class_avg_scores): print("%s = %f" % (class_names_list[index], item)) print("Average precision = ", avg_precision) print("Average recall = ", avg_recall) print("Average F1 score = ", avg_f1) print("Average mean IoU score = ", avg_iou) print("Average run time = ", avg_time)