def test_libs(): img = np.array(Image.open(path['org']), dtype=np.uint8).reshape( (1, 512, 512, 3)) mask = np.array(Image.open(path['mask']).convert('L'), dtype=np.float32) / 255.0 # mask = cv2.GaussianBlur(mask, (5, 5), 2.0) mask_ = np.zeros_like(mask) mask_[mask > 0.5] = 1.0 mask = mask.reshape((1, 512, 512, 1)) arg_mask = 1.0 - mask probs = np.concatenate([arg_mask, mask], axis=3) import utils crf = utils.dense_crf(probs, img) plt.figure() plt.subplot(311) plt.title('image') plt.imshow(img[0, :, :, :], cmap='gray') plt.subplot(312) plt.title('mask') plt.imshow(mask_, cmap='gray') plt.subplot(313) plt.title('crf') plt.imshow(crf[0, :, :, 1], cmap='gray') plt.show()
def predict_img(net, full_img): global hou net.eval() full_img = full_img.unsqueeze(0) start = time.time() pred_mask = net(full_img) end = time.time() # print(start-end) hou = hou + end - start pred_mask = pred_mask > 0.5 pred_mask = pred_mask.float() # pred_mask_crop = F.sigmoid(pred_mask_crop) mask_pred_show = pred_mask.detach().cpu().numpy() mask_pred_show = mask_pred_show.squeeze().astype(np.float32) # plt.figure(0) # plt.imshow(mask_pred_show) # plt.figure(1) # img_show = img_crop.squeeze().cpu() # plt.imshow(img_show[0]) # plt.show() pred_mask = pred_mask.detach().squeeze() pred_mask = pred_mask.unsqueeze(0).cpu() # print(pred_mask_crop.shape) full_mask = pred_mask.squeeze().cpu() full_mask = np.array(full_mask * 255, dtype=np.uint8) crf_img = full_img.squeeze().cpu() crf_img = TF.to_pil_image(crf_img) full_mask = dense_crf(np.array(crf_img, dtype=np.uint8), full_mask) full_mask = full_mask.astype(np.float32) full_mask = torch.from_numpy(full_mask) full_mask = full_mask.unsqueeze(0) return full_mask
def predict(model, dataloader, out_dir, device, sample_index_list): ''' 输出预测结果 :param model: :param dataset: :param out_dir: :param device: :return: None ''' if not os.path.exists(out_dir): os.mkdir(out_dir) # eval mode model.eval() with torch.no_grad(): for batch, item in tqdm(enumerate(dataloader)): data, _ = item data = data.to(device) out = model(data) # score1 = model(data) # # score2 = model(torch.flip(data, [0, 3])) # # score2 = score2.cpu().numpy() # score2 = torch.flip(score2, [3, 0]) # # score3 = model(torch.flip(data, [0, 2])) # # score3 = score3.cpu().numpy() # score3 = torch.flip(score3, [2, 0]) # # out = (score1 + score2 + score3) / 3.0 if dataloader.batch_size == 1: mean = [0.485, 0.456, 0.406] # dataLoader中设置的mean参数 std = [0.229, 0.224, 0.225] # dataLoader中设置的std参数 data = data.squeeze().cpu().numpy() out = F.softmax(out, dim=1) out = out.squeeze().cpu().numpy() for i in range(len(mean)): # 反标准化 data[i] = data[i] * std[i] + mean[i] data = np.array(data * 255).astype(np.uint8).transpose( (1, 2, 0)) # 反ToTensor(),从[0,1]转为[0,255] pred = dense_crf(data, out) sample_index = sample_index_list[batch * dataloader.batch_size] out_name = out_dir + f'/{sample_index}.png' cv2.imwrite(out_name, pred + 1) # 提交的结果需要1~10 else: pred = torch.argmax(out, dim=1).cpu().numpy() for i in range(len(pred)): sample_index = sample_index_list[batch * dataloader.batch_size + i] out_name = out_dir + f'/{sample_index}.png' cv2.imwrite(out_name, pred[i] + 1) # 提交的结果需要1~10
def predict_img(net, full_img, scale_factor=0.5, out_threshold=0.5, use_dense_crf=True, use_gpu=False): img_height = full_img.size[1] img_width = full_img.size[0] img = resize_and_crop(full_img, scale=scale_factor) img = normalize(img) left_square, right_square = split_img_into_squares(img) left_square = hwc_to_chw(left_square) right_square = hwc_to_chw(right_square) X_left = torch.from_numpy(left_square).unsqueeze(0) X_right = torch.from_numpy(right_square).unsqueeze(0) if use_gpu: X_left = X_left.cuda() X_right = X_right.cuda() with torch.no_grad(): output_left = net(X_left) output_right = net(X_right) left_probs = F.sigmoid(output_left).squeeze(0) right_probs = F.sigmoid(output_right).squeeze(0) ''' tf = transforms.Compose( [ transforms.ToPILImage(), transforms.Resize(img_height), transforms.ToTensor() ] ) ''' tf = transforms.Compose([ transforms.ToPILImage(), transforms.Scale(img_height), transforms.ToTensor() ]) left_probs = tf(left_probs.cpu()) right_probs = tf(right_probs.cpu()) left_mask_np = left_probs.squeeze().cpu().numpy() right_mask_np = right_probs.squeeze().cpu().numpy() full_mask = merge_masks(left_mask_np, right_mask_np, img_width) if use_dense_crf: full_mask = dense_crf(np.array(full_img).astype(np.uint8), full_mask) return full_mask > out_threshold
def eval_net(net, dataset, gpu=False): tot = 0 for i, b in enumerate(dataset): X = b[0] y = b[1] X = torch.FloatTensor(X).unsqueeze(0) y = torch.ByteTensor(y).unsqueeze(0) if gpu: X = Variable(X, volatile=True).cuda() y = Variable(y, volatile=True).cuda() else: X = Variable(X, volatile=True) y = Variable(y, volatile=True) y_pred = net(X) y_pred = (F.sigmoid(y_pred) > 0.6).float() # y_pred = F.sigmoid(y_pred).float() y_pred = y_pred.view(384, 384) y = y.view(384, 384) dice = dice_coeff(y_pred, y.float()).data[0] tot += dice if 0: X = X.data.squeeze(0).cpu().numpy() X = np.transpose(X, axes=[1, 2, 0]) y = y.data.squeeze(0).cpu().numpy() y_pred = y_pred.data.squeeze(0).squeeze(0).cpu().numpy() print(y_pred.shape) fig = plt.figure() ax1 = fig.add_subplot(1, 4, 1) ax1.imshow(X) ax2 = fig.add_subplot(1, 4, 2) ax2.imshow(y) ax3 = fig.add_subplot(1, 4, 3) ax3.imshow((y_pred > 0.5)) Q = dense_crf(((X * 255).round()).astype(np.uint8), y_pred) ax4 = fig.add_subplot(1, 4, 4) print(Q) ax4.imshow(Q > 0.5) plt.show() return tot / i
def predict_img(net, full_img, device, scale_factor=1, out_threshold=0.5, use_dense_crf=False): net.eval() img_height = full_img.size[1] img = resize_and_crop(full_img, scale=scale_factor) img = normalize(img) img = hwc_to_chw(img) X = torch.from_numpy(img).unsqueeze(0) X = X.to(device=device) with torch.no_grad(): output = net(X) if net.n_classes > 1: probs = F.softmax(output, dim=1) else: probs = torch.sigmoid(output) probs = probs.squeeze(0) tf = transforms.Compose( [ transforms.ToPILImage(), transforms.Resize(img_height), transforms.ToTensor() ] ) probs = tf(probs.cpu()) full_mask = probs.squeeze().cpu().numpy() if use_dense_crf: full_mask = dense_crf(np.array(full_img).astype(np.uint8), full_mask) return full_mask > out_threshold
def predict_img(net, full_img, scale_factor=0.5, out_threshold=0.5, use_dense_crf=True, use_gpu=False): net.eval() img = resize_and_crop(full_img, scale=scale_factor) img = normalize(img) img = hwc_to_chw(img) X = torch.from_numpy(img).unsqueeze(0) if use_gpu: X = X.cuda() with torch.no_grad(): output = net(X) probs = output.squeeze(0) tf = transforms.Compose( [ transforms.ToPILImage(), transforms.ToTensor() ] ) probs = tf(probs.cpu()) print("Probs - ", probs.shape) mask = probs.squeeze().cpu().numpy() print("Mask - ", mask.shape) plt.imshow(mask) plt.show() if use_dense_crf: mask = dense_crf(np.array(full_img).astype(np.uint8), mask) return mask > out_threshold
def predict_img_batch(net, full_img, scale_factor=0.5, out_threshold=0.5, use_dense_crf=True, use_gpu=True): """return fullmask with size (C, H, W)""" net.eval() img_height = full_img.size[1] img_width = full_img.size[0] print('imgheight', img_height) print('imgwidth', img_width) img = resize_and_crop(full_img, scale=scale_factor) img = normalize(img) if len(img.shape) == 2: img = img[..., np.newaxis] print('img.shape', img.shape) left_square, right_square = split_img_into_squares(img) left_square = hwc_to_chw(left_square) right_square = hwc_to_chw(right_square) X_left = torch.from_numpy(left_square).unsqueeze(0) X_right = torch.from_numpy(right_square).unsqueeze(0) if use_gpu: X_left = X_left.cuda() X_right = X_right.cuda() with torch.no_grad(): output_left = net(X_left) output_right = net(X_right) print('output_left.shape', output_left.shape) print('output_right.shape', output_right.shape) left_probs = output_left.squeeze(0) right_probs = output_right.squeeze(0) # # if not scale_factor==1: # tf = transforms.Compose( # [ # transforms.ToPILImage(), # transforms.Resize(img_height), # transforms.ToTensor() # ] # ) # # left_probs = tf(left_probs.cpu()) # right_probs = tf(right_probs.cpu()) # print('left_probs', left_probs.shape) # print('right_probs', right_probs.shape) left_mask_np = left_probs.squeeze().cpu().numpy() right_mask_np = right_probs.squeeze().cpu().numpy() left_mask_np = np.transpose(left_mask_np, axes=[1, 2, 0]) right_mask_np = np.transpose(right_mask_np, axes=[1, 2, 0]) if not scale_factor == 1: right_mask_np = resize_np(right_mask_np, 1 / scale_factor) left_mask_np = resize_np(left_mask_np, 1 / scale_factor) print('left_mask_np', left_mask_np.shape) print('right_mask_np', right_mask_np.shape) left_mask_np = np.transpose(left_mask_np, axes=[2, 0, 1]) right_mask_np = np.transpose(right_mask_np, axes=[2, 0, 1]) full_mask = merge_masks(left_mask_np, right_mask_np, img_width) # if use_dense_crf: if 0: full_mask = dense_crf(np.array(full_img).astype(np.uint8), full_mask) return full_mask
def predict_img(net, full_img, scale_factor=0.5, out_threshold=0.5, use_dense_crf=False, use_gpu=True): img_height = full_img.size[1] img = full_img.resize((128, 128)) img = np.array(img, dtype=np.float32) imgs_switched = hwc_to_chw(img) imgs_normalized = normalize(imgs_switched) imgs_normalized = torch.from_numpy(imgs_normalized).unsqueeze(0) if use_gpu: imgs_normalized = imgs_normalized.cuda() with torch.no_grad(): output = net(imgs_normalized) prob = torch.sigmoid(output).squeeze(0) tf = transforms.Compose([ transforms.ToPILImage(), transforms.Resize(img_height), transforms.ToTensor() ]) prob = tf(prob.cpu()) full_mask = prob.squeeze().cpu().numpy() '''#full_img = full_img.resize((128,128)) img_height = full_img.size[1] img_width = full_img.size[0] img = resize_and_crop(full_img, scale=scale_factor) img = normalize(img) left_square, right_square = split_img_into_squares(img) left_square = hwc_to_chw(left_square) right_square = hwc_to_chw(right_square) X_left = torch.from_numpy(left_square).unsqueeze(0) X_right = torch.from_numpy(right_square).unsqueeze(0) if use_gpu: X_left = X_left.cuda() X_right = X_right.cuda() with torch.no_grad(): output_left = net(X_left) output_right = net(X_right) left_probs = torch.sigmoid(output_left).squeeze(0) right_probs = torch.sigmoid(output_right).squeeze(0) tf = transforms.Compose( [ transforms.ToPILImage(), transforms.Resize(img_height), transforms.ToTensor() ] ) left_probs = tf(left_probs.cpu()) right_probs = tf(right_probs.cpu()) left_mask_np = left_probs.squeeze().cpu().numpy() right_mask_np = right_probs.squeeze().cpu().numpy() #print(left_mask_np.shape, right_mask_np.shape) full_mask = merge_masks(left_mask_np, right_mask_np, img_width)''' ipdb.set_trace() if use_dense_crf: full_mask = dense_crf(np.array(full_img).astype(np.uint8), full_mask) return full_mask > out_threshold
def VGG16(img_input, dropout=False, with_CPFE=False, with_CA=False, with_SA=False, droup_rate=0.3): # Block 1 x = Conv2D(64, (3, 3), activation='relu', padding='same', name='block1_conv1')(img_input) x = Conv2D(64, (3, 3), activation='relu', padding='same', name='block1_conv2')(x) C1 = x x = MaxPooling2D((2, 2), strides=(2, 2), name='block1_pool')(x) if dropout: x = Dropout(droup_rate)(x) # Block 2 x = Conv2D(128, (3, 3), activation='relu', padding='same', name='block2_conv1')(x) x = Conv2D(128, (3, 3), activation='relu', padding='same', name='block2_conv2')(x) C2 = x x = MaxPooling2D((2, 2), strides=(2, 2), name='block2_pool')(x) if dropout: x = Dropout(droup_rate)(x) # Block 3 x = Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv1')(x) x = Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv2')(x) x = Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv3')(x) C3 = x x = MaxPooling2D((2, 2), strides=(2, 2), name='block3_pool')(x) if dropout: x = Dropout(droup_rate)(x) # Block 4 x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block4_conv1')(x) x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block4_conv2')(x) x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block4_conv3')(x) C4 = x x = MaxPooling2D((2, 2), strides=(2, 2), name='block4_pool')(x) if dropout: x = Dropout(droup_rate)(x) # Block 5 x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block5_conv1')(x) x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block5_conv2')(x) x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block5_conv3')(x) if dropout: x = Dropout(droup_rate)(x) C5 = x C1 = Conv2D(64, (3, 3), padding='same', name='C1_conv')(C1) C1 = BN(C1, 'C1_BN') C2 = Conv2D(64, (3, 3), padding='same', name='C2_conv')(C2) C2 = BN(C2, 'C2_BN') if with_CPFE: C3_cfe = CFE(C3, 32, 'C3_cfe') C4_cfe = CFE(C4, 32, 'C4_cfe') C5_cfe = CFE(C5, 32, 'C5_cfe') C5_cfe = BilinearUpsampling(upsampling=(4, 4), name='C5_cfe_up4')(C5_cfe) C4_cfe = BilinearUpsampling(upsampling=(2, 2), name='C4_cfe_up2')(C4_cfe) C345 = Concatenate(name='C345_aspp_concat', axis=-1)([C3_cfe, C4_cfe, C5_cfe]) if with_CA: C345 = ChannelWiseAttention( C345, name='C345_ChannelWiseAttention_withcpfe') C345 = Conv2D(64, (1, 1), padding='same', name='C345_conv')(C345) C345 = BN(C345, 'C345') C345 = BilinearUpsampling(upsampling=(4, 4), name='C345_up4')(C345) if with_SA: SA = SpatialAttention(C345, 'spatial_attention') C2 = BilinearUpsampling(upsampling=(2, 2), name='C2_up2')(C2) C12 = Concatenate(name='C12_concat', axis=-1)([C1, C2]) C12 = Conv2D(64, (3, 3), padding='same', name='C12_conv')(C12) C12 = BN(C12, 'C12') C12 = Multiply(name='C12_atten_mutiply')([SA, C12]) fea = Concatenate(name='fuse_concat', axis=-1)([C12, C345]) sa = Conv2D(1, (3, 3), padding='same', name='sa')(fea) if False: sa = tf.sigmoid(sa) * 255 sa = dense_crf(np.expand_dims(np.expand_dims(sa, 0), 3), np.expand_dims(img_input, 0)) sa = sa[0, :, :, 0] sa = sa * (sa > 50) # filter not-so-saliency regions threshold_gray = 2 connectivity = 8 sa = sa.astype(np.uint8) _, sa_bi = cv2.threshold(sa, threshold_gray, 255, 0) output = cv2.connectedComponentsWithStats(sa_bi, connectivity, cv2.CV_32S) stats = output[2] # a postprocess for commidity object only area_img = img_org.shape[0] * img_org.shape[1] threshold_area = 100 # set the region to non-saliency, that area is so small for rgns in range(1, stats.shape[0]): if area_img / stats[rgns, 4] <= threshold_area: continue x1, y1 = stats[rgns, 0], stats[rgns, 1] x2, y2 = x1 + stats[rgns, 2], y1 + stats[rgns, 3] sa[y1:y2, x1:x2] = 0 _, sa = cv2.threshold(sa, threshold_gray, 255, 0) model = Model(inputs=img_input, outputs=sa, name="BaseModel") return model
def evaluate_test(model, test_ds, num_test_examples, cspace, epochs, save_model_path=None, type_train='',write_images=True, it=0): if (save_model_path != None): model = models.load_model( save_model_path, custom_objects={ 'bce_dice_loss': bce_dice_loss, 'dice_loss': dice_loss }) # Let's visualize some of the outputs mjccard = 0 score = 0 v_jaccard = np.zeros(num_test_examples) v_sensitivity = np.zeros(num_test_examples) v_specificity = np.zeros(num_test_examples) v_accuracy = np.zeros(num_test_examples) v_dice = np.zeros(num_test_examples) crf_jaccard = np.zeros(num_test_examples) crf_sensitivity = np.zeros(num_test_examples) crf_specificity = np.zeros(num_test_examples) crf_accuracy = np.zeros(num_test_examples) crf_dice = np.zeros(num_test_examples) data_aug_iter = test_ds.make_one_shot_iterator() next_element = data_aug_iter.get_next() if(not os.path.exists('pos_results/' + type_train + cspace + '/' + str(epochs) + '/' + str(it) + '/predict/')): os.makedirs('pos_results/' + type_train + cspace + '/' + str(epochs) + '/' + str(it) + '/predict/') for j in range(num_test_examples): # Running next element in our graph will produce a batch of images batch_of_imgs, label = tf.keras.backend.get_session().run(next_element) img = batch_of_imgs[0] predicted_label = model.predict(batch_of_imgs)[0] mpimg.imsave('pos_results/' + type_train + cspace + '/' + str(epochs) + '/' + str(it) + '/predict/' + str(j) + '.png', predicted_label[:,:,0]) mask_pred = (predicted_label[:, :, 0] > 0.55).astype(int) label = label.astype(int) v_jaccard[j] = fjaccard(label[0, :, :, 0], mask_pred) v_sensitivity[j] = utils.sensitivity(label[0,:,:,0], mask_pred) v_specificity[j] = utils.specificity(label[0,:,:,0], mask_pred) v_accuracy[j] = utils.accuracy(label[0,:,:,0], mask_pred) v_dice[j] = utils.dice_coeff(label[0,:,:,0], mask_pred) score += v_jaccard[j] if v_jaccard[j] >= 0.65 else 0 print(score) mjccard += v_jaccard[j] img_rgb = img[:, :, :3] if(cspace == 'HSV'): img_rgb = tf.keras.backend.get_session().run(tf.image.hsv_to_rgb(img_rgb)) elif(cspace == 'LAB'): img_rgb = tf.keras.backend.get_session().run(Conv_img.lab_to_rgb(img_rgb)) crf_mask = utils.dense_crf(np.array(img_rgb*255).astype(np.uint8), np.array(predicted_label[:, :, 0]).astype(np.float32)) crf_jaccard[j] = fjaccard(label[0, :, :, 0], crf_mask) crf_sensitivity[j] = utils.sensitivity(label[0,:,:,0], crf_mask) crf_specificity[j] = utils.specificity(label[0,:,:,0], crf_mask) crf_accuracy[j] = utils.accuracy(label[0,:,:,0], crf_mask) crf_dice[j] = utils.dice_coeff(label[0,:,:,0], crf_mask) if(write_images): fig = plt.figure(figsize=(25, 25)) plt.subplot(1, 4, 1) plt.imshow(img[:, :, :3]) plt.title("Input image") plt.subplot(1, 4, 2) plt.imshow(label[0, :, :, 0]) plt.title("Actual Mask") plt.subplot(1, 4, 3) plt.imshow(predicted_label[:, :, 0] > 0.55) plt.title("Predicted Mask\n" + "Jaccard = " + str(v_jaccard[j]) + '\nSensitivity = ' + str(v_sensitivity[j]) + '\nSpecificity = ' + str(v_specificity[j]) + '\nAccuracy = ' + str(v_accuracy[j]) + '\nDice = ' + str(v_dice[j])) plt.subplot(1, 4, 4) plt.imshow(crf_mask) plt.title("CRF Mask\n" + "Jaccard = " + str(crf_jaccard[j]) + '\nSensitivity = ' + str(crf_sensitivity[j]) + '\nSpecificity = ' + str(crf_specificity[j]) + '\nAccuracy = ' + str(crf_accuracy[j]) + '\nDice = ' + str(crf_dice[j])) fig.savefig( 'pos_results/' + type_train + cspace + '/' + str(epochs) + '/' + str(it) + '/' + str(j) + '.png', bbox_inches='tight') plt.close(fig) mpimg.imsave('pos_results/' + type_train + cspace + '/' + str(epochs) + '/' + str(it) + '/predict/' + str(j) + '.png', predicted_label[:,:,0]) plt.close() mjccard /= num_test_examples score /= num_test_examples np.savetxt('pos_results/' + type_train + cspace + '/' + str(epochs) + '/' + str(it) + '/jaccard', v_jaccard) np.savetxt('pos_results/' + type_train + cspace + '/' + str(epochs) + '/' + str(it) + '/sensitivity', v_sensitivity) np.savetxt('pos_results/' + type_train + cspace + '/' + str(epochs) + '/' + str(it) + '/specificity', v_specificity) np.savetxt('pos_results/' + type_train + cspace + '/' + str(epochs) + '/' + str(it) + '/accuracy', v_accuracy) np.savetxt('pos_results/' + type_train + cspace + '/' + str(epochs) + '/' + str(it) + '/dice', v_dice) with open('pos_results/' + type_train + cspace + '/' + str(epochs) + '/' + str(it) + '/score','w') as f: f.write('Score = ' + str(score) + '\nSensitivity = ' + str(np.mean(v_sensitivity)) + '\nSpecificity = ' + str(np.mean(v_specificity)) + '\nAccuracy = ' + str(np.mean(v_accuracy)) + '\nDice = ' + str(np.mean(v_dice)) + '\nJaccars = ' + str(np.mean(v_jaccard))) np.savetxt('pos_results/' + type_train + cspace + '/' + str(epochs) + '/' + str(it) + '/crf_jaccard', crf_jaccard) np.savetxt('pos_results/' + type_train + cspace + '/' + str(epochs) + '/' + str(it) + '/crf_sensitivity', crf_sensitivity) np.savetxt('pos_results/' + type_train + cspace + '/' + str(epochs) + '/' + str(it) + '/crf_crf_specificity', crf_specificity) np.savetxt('pos_results/' + type_train + cspace + '/' + str(epochs) + '/' + str(it) + '/crf_accuracy', crf_accuracy) np.savetxt('pos_results/' + type_train + cspace + '/' + str(epochs) + '/' + str(it) + '/crf_dice', crf_dice) with open('pos_results/' + type_train + cspace + '/' + str(epochs) + '/' + str(it) + '/crf_score','w') as f: f.write('Sensitivity = ' + str(np.mean(crf_sensitivity)) + '\nSpecificity = ' + str(np.mean(crf_specificity)) + '\nAccuracy = ' + str(np.mean(crf_accuracy)) + '\nDice = ' + str(np.mean(crf_dice)) + '\nJaccars = ' + str(np.mean(crf_jaccard))) print('Jccard = ' + str(mjccard)) print('Score = ' + str(score)) return mjccard, score
def predict_img(net, full_img, scale_factor=0.5, out_threshold=0.5, use_dense_crf=True, use_gpu=False): net.eval() img_height = full_img.size[1] img_width = full_img.size[0] # img = resize_and_crop(full_img, scale=scale_factor) # img = normalize(img) img = np.array(full_img, dtype=np.float32) img = normalize(img) # left_square, right_square = split_img_into_squares(img) # # left_square = hwc_to_chw(left_square) # right_square = hwc_to_chw(right_square) square = hwc_to_chw(img) # # X_left = torch.from_numpy(left_square).unsqueeze(0) # X_right = torch.from_numpy(right_square).unsqueeze(0) img = torch.from_numpy(square).unsqueeze(0) if use_gpu: # X_left = X_left.cuda() # X_right = X_right.cuda() img = img.cuda() with torch.no_grad(): # output_left = net(X_left) # output_right = net(X_right) output = net(img) # left_probs = output_left.squeeze(0) # right_probs = output_right.squeeze(0) # probs = output # .squeeze(0) # arr_probs = np.array(probs.cpu()) # arr_probs = np.transpose # tf = transforms.Compose( # [ # # transforms.ToPILImage(), # # transforms.Resize(img_height), # transforms.ToTensor() # ] # ) # left_probs = tf(left_probs.cpu()) # right_probs = tf(right_probs.cpu()) # probs = tf(arr_probs) # left_mask_np = left_probs.squeeze().cpu().numpy() # right_mask_np = right_probs.squeeze().cpu().numpy() mask_np = output.squeeze().cpu().numpy() # full_mask = merge_masks(left_mask_np, right_mask_np, img_width) if use_dense_crf: # full_mask = dense_crf(np.array(full_img).astype(np.uint8), full_mask) full_mask = dense_crf(np.array(full_img).astype(np.uint8), mask_np) # return full_mask > out_threshold return mask_np > out_threshold