def main(argv): with CytomineJob.from_cli(argv) as job: model_path = os.path.join(str(Path.home()), "models", "thyroid-unet") model_filepath = pick_model(model_path, job.parameters.tile_size, job.parameters.cytomine_zoom_level) device = torch.device(job.parameters.device) unet = Unet(job.parameters.init_fmaps, n_classes=1) unet.load_state_dict(torch.load(model_filepath, map_location=device)) unet.to(device) unet.eval() segmenter = UNetSegmenter(device=job.parameters.device, unet=unet, classes=[0, 1], threshold=job.parameters.threshold) working_path = os.path.join(str(Path.home()), "tmp") tile_builder = CytomineTileBuilder(working_path) builder = SSLWorkflowBuilder() builder.set_n_jobs(1) builder.set_overlap(job.parameters.tile_overlap) builder.set_tile_size(job.parameters.tile_size, job.parameters.tile_size) builder.set_tile_builder(tile_builder) builder.set_border_tiles(Workflow.BORDER_TILES_EXTEND) builder.set_background_class(0) builder.set_distance_tolerance(1) builder.set_seg_batch_size(job.parameters.batch_size) builder.set_segmenter(segmenter) workflow = builder.get() slide = CytomineSlide(img_instance=ImageInstance().fetch( job.parameters.cytomine_id_image), zoom_level=job.parameters.cytomine_zoom_level) results = workflow.process(slide) print("-------------------------") print(len(results)) print("-------------------------") collection = AnnotationCollection() for obj in results: wkt = shift_poly(obj.polygon, slide, zoom_level=job.parameters.cytomine_zoom_level).wkt collection.append( Annotation(location=wkt, id_image=job.parameters.cytomine_id_image, id_terms=[154005477], id_project=job.project.id)) collection.save(n_workers=job.parameters.n_jobs) return {}
def test_video(): cap = cv2.VideoCapture(2) model = Unet(3, 1) model.load_state_dict(torch.load(Model_path)) model.to(device) #card_dataset = CardDataset("data/val", transform=x_transforms,target_transform=y_transforms) #dataloaders = DataLoader(card_dataset, batch_size=1) model.eval() with torch.no_grad(): while True: ret, frame = cap.read() if ret is None: print("camera is not ready") exit(0) frame = frame[0:480, 0:480] img = cv2.resize(frame, (512, 512)) #img = cv2.imread(name,1) x = cv2img_process(img) x_cuda = x.cuda() y = model(x_cuda) y_cpu = y.cpu() img_y = (torch.squeeze(y_cpu).numpy() * -0.4 * 40 / 255.0 - 0.3) / 0.7 img_y = np.where(img_y < 0.3, 0, img_y) img_y = np.where(img_y > 0.3, 1, img_y) cv2.imshow("x", img) cv2.imshow("predict", img_y) #print(img.shape) #print(img_y.shape) #print("max ",img_y.max()) #print("min ",img_y.min()) #print(img_y[250][250]) cv2.waitKey(1)
print("Let's use", torch.cuda.device_count(), "GPUs!") net = nn.DataParallel(net) reuse_weights = True if reuse_weights: net.load_state_dict(torch.load('./models/model_{}.pth'.format(name))) try: best_val_loss = np.load('./models/best_val_loss_{}.npy'.format(name)) except: best_val_loss = np.finfo(np.float64).max print("Model reloaded. Previous lowest validation loss =", str(best_val_loss)) else: best_val_loss = np.finfo(np.float64).max device = torch.device("cuda" if torch.cuda.is_available() else "cpu") net.to(device) criterion = nn.MSELoss() optimizer = torch.optim.Adam(net.parameters(), lr=5e-4, weight_decay=1e-4) best_weights = net.state_dict() num_epochs = 5 train_loss = np.zeros(num_epochs) validation_loss = np.zeros(num_epochs) print('\nStart training') np.savetxt('epochs_completed.txt', np.zeros(1), fmt='%d') for epoch in range(num_epochs): #TODO decide epochs print('-----------------Epoch = %d-----------------' % (epoch + 1)) train_loss[epoch], _ = train(train_loader, net, criterion, optimizer, device, epoch + 1)
def test(): model = Unet(5, 2) model.load_state_dict(torch.load(args.ckp, map_location='cpu')) model.to(device) test_root_dir = "test" PAVE_dataset = SSFPTestDataset(root=test_root_dir) # batch_size has to be divisible by 828 because there are 828 slices per patient batch_size = 1 dataloaders = DataLoader(PAVE_dataset, batch_size=batch_size) model.eval() #import matplotlib.pyplot as plt #plt.ion() test_result_dir = "test_result" if not os.path.exists(test_result_dir): os.makedirs(test_result_dir) patients = np.zeros((1, 832, 2, 224, 832)) with torch.no_grad(): for x, slice_num, patient_num, leg in tqdm(dataloaders): x = x.to(device) y = model(x) output = y.cpu().numpy() if leg[0] == 'left': patients[patient_num, slice_num + 2, :, :192, 80:400] = output[0, :, :, :] else: patients[patient_num, slice_num + 2, :, :192, 480:800] = output[0, :, :, :] for patient_num in range(10): image_filename = os.path.join("/home/mng/scratch/PAVE_Challenge/test/", 'case{}'.format(patient_num + 1), 'ssfp.nii.gz') size_x = nib.load(image_filename).shape[2] patient_output_vessels = np.transpose( (patients[patient_num, :, 0, :size_x, :] >= 0.5), axes=(2, 0, 1)) patient_output_arteries = np.transpose( (patients[patient_num, :, 1, :size_x, :] >= 0.5), axes=(2, 0, 1)) patient_output_veins = np.logical_and( patient_output_vessels, np.logical_not(patient_output_arteries)) results_file = os.path.join( test_result_dir, 'case{}_results_vessels.nii.gz'.format(patient_num + 1)) save_nii(patient_output_vessels.astype(np.uint8), results_file) results_file = os.path.join( test_result_dir, 'case{}_results_arteries.nii.gz'.format(patient_num + 1)) save_nii(patient_output_arteries.astype(np.uint8), results_file) results_file = os.path.join( test_result_dir, 'case{}_results_veins.nii.gz'.format(patient_num + 1)) save_nii(patient_output_veins.astype(np.uint8), results_file)
import torch.optim as optim import numpy as np from tqdm import tqdm import matplotlib.pyplot as plt from unet import Unet, Layer import time import cv2 MODEL_NAME = f"model-{int(time.time())}" # gives a dynamic model name, to just help with things getting messy over time. learning_rate = 0.001 epochs = 4 validation_percentage = 0.1 u_net = Unet() device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") u_net.to(device) optimizer = optim.Adam(u_net.parameters(), lr=learning_rate) loss_func = nn.MSELoss() def filter_img(img00, img01): kernel = np.ones((4, 4), np.uint8) subtract = cv2.subtract((img00 + 15), img01) kernel2 = np.array([[-1, -1, -1], [-1, 9, -1], [-1, -1, -1]]) img03 = cv2.filter2D(subtract, -1, kernel2) img03 = cv2.GaussianBlur(img03, (5, 5), 0) img03 = cv2.Canny(img03, 85, 255) img03 = cv2.morphologyEx(img03, cv2.MORPH_CLOSE, kernel, iterations=1) img03 = cv2.bitwise_not(img03)
def main(argv): """ IMAGES VALID: * 005-TS_13C08351_2-2014-02-12 12.22.44.ndpi | id : 77150767 * 024-12C07162_2A-2012-08-14-17.21.05.jp2 | id : 77150761 * 019-CP_12C04234_2-2012-08-10-12.49.26.jp2 | id : 77150809 IMAGES TEST: * 004-PF_08C11886_1-2012-08-09-19.05.53.jp2 | id : 77150623 * 011-TS_13C10153_3-2014-02-13 15.22.21.ndpi | id : 77150611 * 018-PF_07C18435_1-2012-08-17-00.55.09.jp2 | id : 77150755 """ with Cytomine.connect_from_cli(argv): parser = ArgumentParser() parser.add_argument("-b", "--batch_size", dest="batch_size", default=4, type=int) parser.add_argument("-j", "--n_jobs", dest="n_jobs", default=1, type=int) parser.add_argument("-e", "--epochs", dest="epochs", default=1, type=int) parser.add_argument("-d", "--device", dest="device", default="cpu") parser.add_argument("-o", "--overlap", dest="overlap", default=0, type=int) parser.add_argument("-t", "--tile_size", dest="tile_size", default=256, type=int) parser.add_argument("-z", "--zoom_level", dest="zoom_level", default=0, type=int) parser.add_argument("--lr", dest="lr", default=0.01, type=float) parser.add_argument("--init_fmaps", dest="init_fmaps", default=16, type=int) parser.add_argument("--data_path", "--dpath", dest="data_path", default=os.path.join(str(Path.home()), "tmp")) parser.add_argument("-w", "--working_path", "--wpath", dest="working_path", default=os.path.join(str(Path.home()), "tmp")) parser.add_argument("-s", "--save_path", dest="save_path", default=os.path.join(str(Path.home()), "tmp")) args, _ = parser.parse_known_args(argv) os.makedirs(args.save_path, exist_ok=True) os.makedirs(args.data_path, exist_ok=True) os.makedirs(args.working_path, exist_ok=True) # fetch annotations (filter val/test sets + other annotations) all_annotations = AnnotationCollection(project=77150529, showWKT=True, showMeta=True, showTerm=True).fetch() val_ids = {77150767, 77150761, 77150809} test_ids = {77150623, 77150611, 77150755} val_test_ids = val_ids.union(test_ids) train_collection = all_annotations.filter(lambda a: ( a.user in {55502856} and len(a.term) > 0 and a.term[0] in {35777351, 35777321, 35777459} and a.image not in val_test_ids)) val_rois = all_annotations.filter( lambda a: (a.user in {142954314} and a.image in val_ids and len( a.term) > 0 and a.term[0] in {154890363})) val_foreground = all_annotations.filter( lambda a: (a.user in {142954314} and a.image in val_ids and len( a.term) > 0 and a.term[0] in {154005477})) train_wsi_ids = list({an.image for an in all_annotations }.difference(val_test_ids)) val_wsi_ids = list(val_ids) download_path = os.path.join(args.data_path, "crops-{}".format(args.tile_size)) images = { _id: ImageInstance().fetch(_id) for _id in (train_wsi_ids + val_wsi_ids) } train_crops = [ AnnotationCrop(images[annot.image], annot, download_path, args.tile_size, zoom_level=args.zoom_level) for annot in train_collection ] val_crops = [ AnnotationCrop(images[annot.image], annot, download_path, args.tile_size, zoom_level=args.zoom_level) for annot in val_rois ] for crop in train_crops + val_crops: crop.download() np.random.seed(42) dataset = RemoteAnnotationTrainDataset( train_crops, seg_trans=segmentation_transform) loader = DataLoader(dataset, shuffle=True, batch_size=args.batch_size, num_workers=args.n_jobs, worker_init_fn=worker_init) # network device = torch.device(args.device) unet = Unet(args.init_fmaps, n_classes=1) unet.train() unet.to(device) optimizer = Adam(unet.parameters(), lr=args.lr) loss_fn = BCEWithLogitsLoss(reduction="mean") results = { "train_losses": [], "val_losses": [], "val_metrics": [], "save_path": [] } for e in range(args.epochs): print("########################") print(" Epoch {}".format(e)) print("########################") epoch_losses = list() unet.train() for i, (x, y) in enumerate(loader): x, y = (t.to(device) for t in [x, y]) y_pred = unet.forward(x) loss = loss_fn(y_pred, y) optimizer.zero_grad() loss.backward() optimizer.step() epoch_losses = [loss.detach().cpu().item()] + epoch_losses[:5] print("{} - {:1.5f}".format(i, np.mean(epoch_losses))) results["train_losses"].append(epoch_losses[0]) unet.eval() # validation val_losses = np.zeros(len(val_rois), dtype=np.float) val_roc_auc = np.zeros(len(val_rois), dtype=np.float) val_cm = np.zeros([len(val_rois), 2, 2], dtype=np.int) for i, roi in enumerate(val_crops): foregrounds = find_intersecting_annotations( roi.annotation, val_foreground) with torch.no_grad(): y_pred, y_true = predict_roi( roi, foregrounds, unet, device, in_trans=transforms.ToTensor(), batch_size=args.batch_size, tile_size=args.tile_size, overlap=args.overlap, n_jobs=args.n_jobs, zoom_level=args.zoom_level) val_losses[i] = metrics.log_loss(y_true.flatten(), y_pred.flatten()) val_roc_auc[i] = metrics.roc_auc_score(y_true.flatten(), y_pred.flatten()) val_cm[i] = metrics.confusion_matrix( y_true.flatten().astype(np.uint8), (y_pred.flatten() > 0.5).astype(np.uint8)) print("------------------------------") print("Epoch {}:".format(e)) val_loss = np.mean(val_losses) roc_auc = np.mean(val_roc_auc) print("> val_loss: {:1.5f}".format(val_loss)) print("> roc_auc : {:1.5f}".format(roc_auc)) cm = np.sum(val_cm, axis=0) cnt = np.sum(val_cm) print("CM at 0.5 threshold") print("> {:3.2f}% {:3.2f}%".format(100 * cm[0, 0] / cnt, 100 * cm[0, 1] / cnt)) print("> {:3.2f}% {:3.2f}%".format(100 * cm[1, 0] / cnt, 100 * cm[1, 1] / cnt)) print("------------------------------") filename = "{}_e_{}_val_{:0.4f}_roc_{:0.4f}_z{}_s{}.pth".format( datetime.now().timestamp(), e, val_loss, roc_auc, args.zoom_level, args.tile_size) torch.save(unet.state_dict(), os.path.join(args.save_path, filename)) results["val_losses"].append(val_loss) results["val_metrics"].append(roc_auc) results["save_path"].append(filename) return results
parser.add_argument('--load', type=str, default='CP_epoch20.pth', help='Load model') parser.add_argument('--test', type=str, default=None, help='Load test dataset') parser.add_argument('--no-train',dest='train', action='store_false', help='Skip the training phase') parser.set_defaults(train=True) return parser.parse_args() if __name__=='__main__': args = get_args() device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') model = Unet(n_channels=3, n_classes=1) model.to(device=device) train_data, test_data, maps = load_data(organ=args.organ) if args.train: train_net(net=model, body_array_new=train_data, maps_list=maps, epochs=args.epochs, lr=args.lr, device=device, batch_size=args.batchsize) model_eval = Unet(n_channels=3, n_classes=1) model_eval.load_state_dict(torch.load(dir_checkpoint+args.load)) model_eval.to(device=device) eval_net(model=model_eval,body_array_new=test_data, maps_list=maps, device=device)
classes=['bedroom_train'], transform=transform) val_dataset = torchvision.datasets.LSUN(args.val_data, classes=['bedroom_val'], transform=transform) if args.mini_eval: if args.dataset == 'folder': val_dataset, _ = torch.utils.data.random_split( val_dataset, [args.mini_eval, len(val_dataset) - args.mini_eval]) else: dataset, val_dataset = torch.utils.data.random_split( dataset, [len(dataset) - args.mini_eval, args.mini_eval]) dataloader = torch.utils.data.DataLoader(dataset, shuffle=True, batch_size=args.batch_size, drop_last=True) val_dataloader = torch.utils.data.DataLoader(val_dataset, shuffle=True, batch_size=args.batch_size, drop_last=True) mask_generator = MaskGenerator(args.input_size, file_path=args.mask) maskloader = torch.utils.data.DataLoader(mask_generator, shuffle=False, batch_size=args.batch_size) maskiter = iter(maskloader) train(model.to(device), criterion, dataloader, maskloader, val_dataloader)