def validate(cfg, model_path): assert model_path is not None, 'Not assert model path' use_cuda = False if cfg.get("cuda", None) is not None: if cfg.get("cuda", None) != "all": os.environ["CUDA_VISIBLE_DEVICES"] = cfg.get("cuda", None) use_cuda = torch.cuda.is_available() # Setup Dataloader train_loader, val_loader = get_loader(cfg) loss_fn = get_loss_fn(cfg) # Load Model model = get_model(cfg) if use_cuda: model.cuda() loss_fn.cuda() checkpoint = torch.load(model_path) if torch.cuda.device_count() > 1: # multi gpus model = torch.nn.DataParallel( model, device_ids=list(range(torch.cuda.device_count()))) state = checkpoint["state_dict"] else: # 1 gpu state = convert_state_dict(checkpoint["state_dict"]) else: # cpu checkpoint = torch.load(model_path, map_location='cpu') state = convert_state_dict(checkpoint["state_dict"]) model.load_state_dict(state) validate_epoch(val_loader, model, loss_fn, use_cuda)
def test(cfg, img_path, model_path): assert img_path is not None, 'Not assert img' assert model_path is not None, 'Not assert model path' use_cuda = False if cfg.get("cuda", None) is not None: if cfg.get("cuda", None) != "all": os.environ["CUDA_VISIBLE_DEVICES"] = cfg.get("cuda", None) use_cuda = torch.cuda.is_available() # Load Model model = get_model(cfg) if use_cuda: model.cuda() checkpoint = torch.load(model_path) if torch.cuda.device_count() > 1: # multi gpus model = torch.nn.DataParallel(model, device_ids=list(range(torch.cuda.device_count()))) state = checkpoint["state_dict"] else: # 1 gpu state = convert_state_dict(checkpoint["state_dict"]) else: # cpu checkpoint = torch.load(model_path, map_location='cpu') state = convert_state_dict(checkpoint["state_dict"]) model.load_state_dict(state) model.eval() input = get_img(img_path) # read img with torch.no_grad(): if use_cuda: input = input.cuda() output = model(input) # model output idx = torch.argmax(output, 1) idx = int(idx.data) cls = idx2label[idx] print(idx, cls)
def test(img_path, model_path, show=False): imgorg = cv2.imread(img_path) imgorg = cv2.cvtColor(imgorg, cv2.COLOR_BGR2RGB) w, h = imgorg.shape[0], imgorg.shape[1] img = cv2.resize(imgorg, (256, 256)) img = img[:, :, ::-1] img = img.astype(float) / 255 img = img.transpose(2, 0, 1) img = np.expand_dims(img, 0) img = torch.from_numpy(img).float() htan = nn.Hardtanh(0.0, 1.0) model = get_model('unetnc', n_classes=3, in_channels=3) state = convert_state_dict(torch.load(model_path)['model_state']) model.load_state_dict(state) model.eval() model.cuda() images = Variable(img.cuda()) with torch.no_grad(): output = model(images) pred = htan(output) pred = pred.cpu().detach().numpy()[0] if show: pred = pred.transpose((1, 2, 0)) pred = cv2.resize(pred, (h, w), interpolation=cv2.INTER_NEAREST) print(pred) _, axis = plt.subplots(1, 2) axis[0].imshow(imgorg) axis[1].imshow(pred) plt.show()
def main(args, logger): # ================ seed and device =================== np.random.seed(42) torch.manual_seed(42) # if args.cuda: if True: torch.cuda.manual_seed_all(42) device = 'cuda' else: device = 'cpu' # ================= data ==================== mnist = Mnist(args.data_dir, mode='test') val_loader = torch.utils.data.DataLoader(mnist.test_dataset, batch_size=args.batch_size, shuffle=False) # ================== Load Model =================== model = models.get_model(name=args.model, n_class=mnist.n_class) model.to(device) best_model_path = pjoin(args.save_dir, args.model + '_best_model.pkl') state = convert_state_dict(torch.load(best_model_path)["model_state"]) model.load_state_dict(state) # ================== Testing ====================== model.eval() val_acc = 0 with torch.no_grad(): for idx, (img, lab) in enumerate(val_loader): img = img.to(device) lab = lab.to(device) out = model(img) pred = out.argmax(dim=1, keepdim=True) val_acc += pred.eq(lab.view_as(pred)).sum().item() val_acc /= len(val_loader.dataset) logger.write(f'Model {best_model_path}, Acc: {val_acc:.3f}')
def init_model(self, model_path): n_classes = 19 # Setup Model model = get_model({"arch": "hardnet"}, n_classes) state = convert_state_dict( torch.load(model_path, map_location=self.device)["model_state"]) model.load_state_dict(state) model.eval() model.to(self.device) return model
def main(args): # ========= Setup device and seed ============ np.random.seed(42) torch.manual_seed(42) if args.cuda: torch.cuda.manual_seed_all(42) device = 'cuda' if args.cuda else 'cpu' logger = Logger(pjoin(args.save_dir, args.model, 'test.log')) logger.write(f'\nTesting configs: {args}') # ================= Load processed data =================== val_dataset = VOC12(args.data_dir, img_size=args.img_size, split='test') val_loader = DataLoader(val_dataset, num_workers=8, batch_size=1) n_classes = val_dataset.n_classes # ================= Init model ==================== model = models.get_model(name=args.model, n_classes=n_classes) model = model.to(device) state = convert_state_dict(torch.load(args.model_path)["model_state"]) model.load_state_dict(state) model.eval() # ====================== Only one image ========================== if args.eval: with torch.no_grad(): img = Image.open(args.img_path) origin = img.size if args.img_size: img = img.resize( (val_dataset.img_size[0], val_dataset.img_size[1])) img = val_dataset.input_transform(img).unsqueeze(0).to(device) out = model(img) pred = np.squeeze(out.data.max(1)[1].cpu().numpy(), axis=0) decoded = val_dataset.decode_segmap(pred) img_out = ToPILImage()(decoded).resize(origin) img_out.save( pjoin(args.save_dir, args.model, f'eval_{args.img_size}.png')) return # ====================== Testing Many images ============================== with torch.no_grad(): for idx, (name, img) in enumerate(val_loader): img = img.to(device) out = model(img) pred = out.data.max(1)[1].squeeze_(1).squeeze_(0).cpu().numpy() decoded = val_dataset.decode_segmap(pred) ToPILImage()(decoded).save( pjoin(args.save_dir, args.model, f'{name[0]}_{args.img_size}.png'))
def main(args): # ================ seed and device =================== np.random.seed(42) torch.manual_seed(42) if args.cuda: torch.cuda.manual_seed_all(42) device = 'cuda' else: device = 'cpu' logger = Logger(pjoin(args.save_dir, args.model + '_test.log')) logger.write(f'\nConfig: {args}') # ================= data ==================== mnist = Mnist(args.data_dir, mode='test') val_loader = torch.utils.data.DataLoader(mnist.test_dataset, batch_size=args.batch_size, shuffle=False) # ================== Load Model =================== model = models.get_model(name=args.model, n_class=mnist.n_class) model.to(device) best_model_path = args.model_path state = convert_state_dict(torch.load(best_model_path)["model_state"]) model.load_state_dict(state) # ================== Testing ====================== model.eval() val_acc = 0 res = [] with torch.no_grad(): for idx, (img, lab) in enumerate(val_loader): img = img.to(device) lab = lab.to(device) out, tmp = model(img) res.append(tmp.cpu().numpy()) pred = out.argmax(dim=1, keepdim=True) val_acc += pred.eq(lab.view_as(pred)).sum().item() val_acc /= len(val_loader.dataset) logger.write(f'Model {best_model_path}, Acc: {val_acc:.3f}') with open('test.npy', 'wb') as fout: np.save(fout, np.array(res))
def test(args): data_loader = get_loader(args.dataset) data_path = get_data_path() loader = data_loader(data_path, is_transform=True) n_classes = loader.n_classes # Setup Model model = unet(n_classes=n_classes, in_channels=1) state = convert_state_dict(torch.load(args.model_path)['model_state']) model.load_state_dict(state) model.eval() model.cuda(0) # Shannon and Preston's way of processing test files test_dataset = MRI(args.test_root, img_size=(args.img_rows, args.img_cols), mode='test') testLoader = DataLoader(test_dataset, batch_size=1) for (img, gt) in testLoader: img = img.numpy() img = img.astype(np.float64) # img -= loader.mean img -= 128 img = img.astype(float) / 255.0 img = np.expand_dims(img, axis=2) # NHWC -> NCWH # what does this mean? # N = number of images in the batch, H = height of the image, W = width of the image, C = number of channels of the image # https://stackoverflow.com/questions/37689423/convert-between-nhwc-and-nchw-in-tensorflow img = img.transpose(2, 0, 1) img = np.expand_dims(img, 0) img = torch.from_numpy(img).float() images = Variable(img.cuda(0), volatile=True) print("files are read!")
def test(cfg): device = torch.device("cuda:{}".format(cfg["training"]["gpu_idx"]) if torch.cuda.is_available() else "cpu") data_loader = get_loader(cfg["data"]["dataset"]) data_path = cfg["data"]["path"] v_loader = data_loader(data_path, split='val') n_classes = v_loader.n_classes n_val = len(v_loader.files['val']) valLoader = data.DataLoader(v_loader, batch_size=1, num_workers=cfg["training"]["n_workers"]) model = get_model(cfg["model"], n_classes).to(device) state = convert_state_dict( torch.load(cfg["testing"]["trained_model"], map_location=device)["model_state"]) model.load_state_dict(state) model.eval() model.to(device) running_metrics_val = runningScore(n_classes, n_val) with torch.no_grad(): for i_val, (images_val, labels_val, img_name_val) in tqdm(enumerate(valLoader)): images_val = images_val.to(device) labels_val = labels_val.to(device) outputs = model(images_val) pred = np.squeeze(outputs.data.max(1)[1].cpu().numpy()) gt = np.squeeze(labels_val.data.cpu().numpy()) running_metrics_val.update(gt, pred, i_val) decoded = v_loader.decode_segmap(pred, plot=False) m.imsave( pjoin(cfg["testing"]["path"], '{}.bmp'.format(img_name_val[0])), decoded) score = running_metrics_val.get_scores() acc_all, dsc_cls = running_metrics_val.get_list() for k, v in score[0].items(): print(k, v) if cfg["testing"]["boxplot"] == True: sns.set_style("whitegrid") labels = ['CSF', 'Gray Matter', 'White Matter'] fig1, ax1 = plt.subplots() ax1.set_title('Basic Plot') # ax1.boxplot(dsc_cls.transpose()[:,1:n_classes], showfliers=False, labels=labels) ax1 = sns.boxplot(data=dsc_cls.transpose()[:, 1:n_classes]) # ax1.yaxis.grid(True) ax1.set_xlabel('Three separate samples') ax1.set_ylabel('Dice Score') # path to save boxplot plt.savefig('/home/jwliu/disk/kxie/CNN_LSTM/test_results/box.pdf')
def train(cfg, writer, logger): # This statement must be declared before using pytorch use_cuda = False if cfg.get("cuda", None) is not None: if cfg.get("cuda", None) != "all": os.environ["CUDA_VISIBLE_DEVICES"] = cfg.get("cuda", None) use_cuda = torch.cuda.is_available() # Setup random seed seed = cfg["training"].get("seed", random.randint(1, 10000)) torch.manual_seed(seed) if use_cuda: torch.cuda.manual_seed(seed) np.random.seed(seed) random.seed(seed) # Setup Dataloader train_loader, val_loader = get_loader(cfg) # Setup Model model = get_model(cfg) # writer.add_graph(model, torch.rand([1, 3, 224, 224])) if use_cuda and torch.cuda.device_count() > 1: model = torch.nn.DataParallel(model, device_ids=list( range(torch.cuda.device_count()))) # Setup optimizer, lr_scheduler and loss function optimizer = get_optimizer(model.parameters(), cfg) scheduler = get_scheduler(optimizer, cfg) loss_fn = get_loss_fn(cfg) # Setup Metrics epochs = cfg["training"]["epochs"] recorder = RecorderMeter(epochs) start_epoch = 0 # save model parameters every <n> epochs save_interval = cfg["training"]["save_interval"] if use_cuda: model.cuda() loss_fn.cuda() # Resume Trained Model resume_path = os.path.join(writer.file_writer.get_logdir(), cfg["training"]["resume"]) best_path = os.path.join(writer.file_writer.get_logdir(), cfg["training"]["best_model"]) if cfg["training"]["resume"] is not None: if os.path.isfile(resume_path): logger.info( "Loading model and optimizer from checkpoint '{}'".format( resume_path)) checkpoint = torch.load(resume_path) state = checkpoint["state_dict"] if torch.cuda.device_count() <= 1: state = convert_state_dict(state) model.load_state_dict(state) optimizer.load_state_dict(checkpoint["optimizer"]) scheduler.load_state_dict(checkpoint["scheduler"]) start_epoch = checkpoint["epoch"] recorder = checkpoint['recorder'] logger.info("Loaded checkpoint '{}' (epoch {})".format( resume_path, checkpoint["epoch"])) else: logger.info("No checkpoint found at '{}'".format(resume_path)) epoch_time = AverageMeter() for epoch in range(start_epoch, epochs): start_time = time.time() need_hour, need_mins, need_secs = convert_secs2time(epoch_time.avg * (epochs - epoch)) need_time = '[Need: {:02d}:{:02d}:{:02d}]'.format( need_hour, need_mins, need_secs) logger.info( '\n==>>{:s} [Epoch={:03d}/{:03d}] {:s} [learning_rate={:8.6f}]'. format(time_string(), epoch, epochs, need_time, optimizer. param_groups[0]['lr']) + # scheduler.get_last_lr() >=1.4 ' [Best : Accuracy={:.2f}]'.format(recorder.max_accuracy(False))) train_acc, train_los = train_epoch(train_loader, model, loss_fn, optimizer, use_cuda, logger) val_acc, val_los = validate_epoch(val_loader, model, loss_fn, use_cuda, logger) scheduler.step() is_best = recorder.update(epoch, train_los, train_acc, val_los, val_acc) if is_best or epoch % save_interval == 0 or epoch == epochs - 1: # save model (resume model and best model) save_checkpoint( { 'epoch': epoch + 1, 'recorder': recorder, 'state_dict': model.state_dict(), 'optimizer': optimizer.state_dict(), 'scheduler': scheduler.state_dict(), }, is_best, best_path, resume_path) for name, param in model.named_parameters(): # save histogram writer.add_histogram(name, param.clone().cpu().data.numpy(), epoch) writer.add_scalar('Train/loss', train_los, epoch) # save curves writer.add_scalar('Train/acc', train_acc, epoch) writer.add_scalar('Val/loss', val_los, epoch) writer.add_scalar('Val/acc', val_acc, epoch) epoch_time.update(time.time() - start_time) writer.close()
def test(args, img_path, fname): wc_model_file_name = os.path.split(args.wc_model_path)[1] wc_model_name = wc_model_file_name[:wc_model_file_name.find('_')] bm_model_file_name = os.path.split(args.bm_model_path)[1] bm_model_name = bm_model_file_name[:bm_model_file_name.find('_')] wc_n_classes = 3 bm_n_classes = 2 wc_img_size = (256, 256) bm_img_size = (128, 128) # Setup image print("Read Input Image from : {}".format(img_path)) imgorg = m.imread(img_path, mode='RGB') img = m.imresize(imgorg, wc_img_size) img = img[:, :, ::-1] img = img.astype(float) / 255.0 img = img.transpose(2, 0, 1) # NHWC -> NCHW img = np.expand_dims(img, 0) img = torch.from_numpy(img).float() # Predict htan = nn.Hardtanh(0, 1.0) wc_model = get_model(wc_model_name, wc_n_classes, in_channels=3) wc_state = convert_state_dict( torch.load(args.wc_model_path)['model_state']) wc_model.load_state_dict(wc_state) wc_model.eval() bm_model = get_model(bm_model_name, bm_n_classes, in_channels=3) bm_state = convert_state_dict( torch.load(args.bm_model_path)['model_state']) bm_model.load_state_dict(bm_state) bm_model.eval() if torch.cuda.is_available(): wc_model.cuda() bm_model.cuda() images = Variable(img.cuda()) else: images = Variable(img) with torch.no_grad(): wc_outputs = wc_model(images) pred_wc = htan(wc_outputs) bm_input = F.interpolate(pred_wc, bm_img_size) outputs_bm = bm_model(bm_input) # call unwarp uwpred = unwarp(imgorg, outputs_bm) if args.show: f1, axarr1 = plt.subplots(1, 2) axarr1[0].imshow(imgorg) axarr1[1].imshow(uwpred) plt.show() # Save the output outp = os.path.join(args.out_path, fname) cv2.imwrite(outp, uwpred[:, :, ::-1] * 255)
def test(args, img_path, fname): wc_model_file_name = os.path.split(args.wc_model_path)[1] wc_model_name = wc_model_file_name[:wc_model_file_name.find('_')] bm_model_file_name = os.path.split(args.bm_model_path)[1] bm_model_name = bm_model_file_name[:bm_model_file_name.find('_')] wc_n_classes = 3 bm_n_classes = 2 wc_img_size = (256, 256) bm_img_size = (128, 128) # Setup image print("Read Input Image from : {}".format(img_path)) imgorg = cv2.imread(img_path) imgorg = cv2.cvtColor(imgorg, cv2.COLOR_BGR2RGB) img = cv2.resize(imgorg, wc_img_size) img = img[:, :, ::-1] img = img.astype(float) / 255.0 img = img.transpose(2, 0, 1) # NHWC -> NCHW img = np.expand_dims(img, 0) img = torch.from_numpy(img).float() # Predict htan = nn.Hardtanh(0, 1.0) wc_model = get_model(wc_model_name, wc_n_classes, in_channels=3) if DEVICE.type == 'cpu': wc_state = convert_state_dict(torch.load( args.wc_model_path, map_location='cpu')['model_state']) else: wc_state = convert_state_dict( torch.load(args.wc_model_path)['model_state']) wc_model.load_state_dict(wc_state) wc_model.eval() bm_model = get_model(bm_model_name, bm_n_classes, in_channels=3) if DEVICE.type == 'cpu': bm_state = convert_state_dict(torch.load( args.bm_model_path, map_location='cpu')['model_state']) else: bm_state = convert_state_dict( torch.load(args.bm_model_path)['model_state']) bm_model.load_state_dict(bm_state) bm_model.eval() if torch.cuda.is_available(): wc_model.cuda() bm_model.cuda() images = Variable(img.cuda()) else: images = Variable(img) with torch.no_grad(): wc_outputs = wc_model(images) pred_wc = htan(wc_outputs) bm_input = F.interpolate(pred_wc, bm_img_size, mode='bilinear', align_corners=True) outputs_bm = bm_model(bm_input) # call unwarp wc = pred_wc[0].cpu().detach().numpy().transpose((1, 2, 0)) wc = cv2.resize(wc, (imgorg.shape[1], imgorg.shape[0])) mask = (wc * 255).astype(np.uint8) _, binary_im = cv2.threshold(mask, 1, 255, cv2.THRESH_BINARY) # binary_im = binary_im.astype(np.float32) / 255.0 out = cv2.bitwise_and(imgorg, binary_im) bm = outputs_bm[0].cpu().detach().numpy().transpose((1, 2, 0)) bm = cv2.resize(bm, (imgorg.shape[1], imgorg.shape[0])) uwpred = unwarp(imgorg, outputs_bm) if args.show: f1, axarr1 = plt.subplots(1, 6) axarr1[0].imshow(imgorg) axarr1[1].imshow(wc) axarr1[2].imshow(bm[:, :, 0]) axarr1[3].imshow(uwpred) axarr1[4].imshow(binary_im, cmap='gray') axarr1[5].imshow(out) plt.show() # Save the output mask_out = os.path.join(args.out_path, fname[:-4] + '___.png') img_out = os.path.join(args.out_path, fname) wc_out = os.path.join(args.out_path, fname[:-4] + '__.png') cv2.imwrite(img_out, uwpred[:, :, ::-1]*255) cv2.imwrite(wc_out, wc[:, :, ::-1]*255) cv2.imwrite(mask_out, out[:, :, ::-1])
img = Image.fromarray(img, "YCbCr").convert("RGB") return img opt = parser.parse_args() cuda = opt.cuda if cuda: print("=> use gpu id: '{}'".format(opt.gpus)) os.environ["CUDA_VISIBLE_DEVICES"] = opt.gpus if not torch.cuda.is_available(): raise Exception( "No GPU found or Wrong gpu id, please run without --cuda") model = MemNet(1, 64, 6, 6) state = convert_state_dict(torch.load(opt.model)['model']) #Since using multiple card for training model, so we need employ convert_state_dict() to remove the module prefix when loading module model.load_state_dict(state) im_gt_ycbcr = imread("data/SuperResolution/Set5/" + opt.image + ".bmp", mode="YCbCr") im_b_ycbcr = imread("data/SuperResolution/Set5/" + opt.image + "_scale_" + str(opt.scale) + ".bmp", mode="YCbCr") im_gt_y = im_gt_ycbcr[:, :, 0].astype(float) im_b_y = im_b_ycbcr[:, :, 0].astype(float) psnr_bicubic = PSNR(im_gt_y, im_b_y, shave_border=opt.scale) im_input = im_b_y / 255.
if __name__ == "__main__": transformations = transforms.Compose([transforms.ToTensor()]) custom_mnist_from_images = \ CustomDatasetFromImagesEval('../data/iris_segmentation/lists/eval.csv') mn_dataset_loader = torch.utils.data.DataLoader( dataset=custom_mnist_from_images, batch_size=1, shuffle=False, num_workers=8) model = segnet() ckpt = torch.load("./best_model_22_1200.pkl") state = convert_state_dict(ckpt['model_state']) model.load_state_dict(state) model = torch.nn.DataParallel(model, device_ids=range(torch.cuda.device_count() - 1)) model.cuda() with torch.no_grad(): for i, (images, labels, name) in enumerate(mn_dataset_loader): images = Variable(images.cuda()) labels = Variable(labels.cuda()) #images = Variable(images) #labels = Variable(labels) # Forward pass outputs = model(images) #print(outputs.size()) img_array = outputs.cpu().numpy()
def test(args): # Setup image print("Read Input Image from : {}".format(args.img_path)) img = misc.imread(args.img_path) data_loader = get_loader(args.dataset) data_path = get_data_path(args.dataset) loader = data_loader(data_path, is_transform=True) n_classes = loader.n_classes resized_img = misc.imresize(img, (loader.img_size[0], loader.img_size[1]), interp='bicubic') img = img[:, :, ::-1] img = img.astype(np.float64) img -= loader.mean img = misc.imresize(img, (loader.img_size[0], loader.img_size[1])) img = img.astype(float) / 255.0 # NHWC -> NCWH img = img.transpose(2, 0, 1) img = np.expand_dims(img, 0) img = torch.from_numpy(img).float() # Setup Model model = get_model('fcn8s', n_classes) state = convert_state_dict(torch.load(args.model_path)['model_state']) model.load_state_dict(state) model.eval() model.cuda(0) images = Variable(img.cuda(0), volatile=True) outputs = F.softmax(model(images), dim=1) if args.dcrf == "True": unary = outputs.data.cpu().numpy() unary = np.squeeze(unary, 0) unary = -np.log(unary) unary = unary.transpose(2, 1, 0) w, h, c = unary.shape unary = unary.transpose(2, 0, 1).reshape(loader.n_classes, -1) unary = np.ascontiguousarray(unary) resized_img = np.ascontiguousarray(resized_img) d = dcrf.DenseCRF2D(w, h, loader.n_classes) d.setUnaryEnergy(unary) d.addPairwiseBilateral(sxy=5, srgb=3, rgbim=resized_img, compat=1) q = d.inference(50) mask = np.argmax(q, axis=0).reshape(w, h).transpose(1, 0) decoded_crf = loader.decode_segmap(np.array(mask, dtype=np.uint8)) dcrf_path = args.out_path[:-4] + '_drf.png' misc.imsave(dcrf_path, decoded_crf) print("Dense CRF Processed Mask Saved at: {}".format(dcrf_path)) if torch.cuda.is_available(): model.cuda(0) images = Variable(img.cuda(0), volatile=True) else: images = Variable(img, volatile=True) pred = np.squeeze(outputs.data.max(1)[1].cpu().numpy(), axis=0) decoded = loader.decode_segmap(pred) print('Classes found: ', np.unique(pred)) misc.imsave(args.out_path, decoded) print("Segmentation Mask Saved at: {}".format(args.out_path))