def main(): args = build_parser().parse_args() image_size = [args.img_height, args.img_width] # config = tf.ConfigProto() # config.gpu_options.per_process_gpu_memory_fraction = 1.0 # sess = tf.Session(config=config) sess = tf.Session() unet = Unet(input_shape=image_size, sess=sess, filter_num=args.filter_num, batch_norm=args.batch_norm) unet.build_net() if args.checkpoint_path: unet.load_weights(args.checkpoint_path) images, masks = read_data(args.train_dir, args.train_mask_dir, n_images=args.n_images, image_size=image_size) val_images, val_masks = read_data(args.val_dir, args.val_mask_dir, n_images=args.n_images // 4, image_size=image_size) unet.train(images=images, masks=masks, val_images=val_images, val_masks=val_masks, epochs=args.epochs, batch_size=args.batch_size, learning_rate=args.learning_rate, dice_loss=args.dice_loss, always_save=args.always_save)
def train(): model = Unet(5, 2).to(device) model.train() batch_size = args.batch_size criterion = torch.nn.BCELoss() optimizer = optim.Adam(model.parameters()) PAVE_dataset = SSFPDataset("train", transform=1, target_transform=1) dataloaders = DataLoader(PAVE_dataset, batch_size=batch_size, shuffle=True, num_workers=0) train_model(model, criterion, optimizer, dataloaders)
itt = itt + 1 scheduler_unet_qpi2dapi = optim.lr_scheduler.StepLR( optimizer_unet_qpi2dapi, 2000, gamma=0.1, last_epoch=-1) scheduler_unet_dapi2qpi = optim.lr_scheduler.StepLR( optimizer_unet_dapi2qpi, 2000, gamma=0.1, last_epoch=-1) scheduler_D_dapi = optim.lr_scheduler.StepLR(optimizer_D_dapi, 2000, gamma=0.1, last_epoch=-1) scheduler_D_qpi = optim.lr_scheduler.StepLR(optimizer_D_qpi, 2000, gamma=0.1, last_epoch=-1) unet_qpi2dapi.train() D_dapi.train() unet_dapi2qpi.train() D_qpi.train() # # for p in unet_qpi2dapi.parameters(): # p.requires_grad = False # for p in unet_dapi2qpi.parameters(): # p.requires_grad = False # for p in D_dapi.parameters(): # p.requires_grad = True # for p in D_qpi.parameters(): # p.requires_grad = True # # for t in range(n_critic): #
train_iters = [] test_iters = [0] stop = 0 itt = 0 start_sl = 0 stop = 0 itt = 0 while itt < iterace and stop == 0: itt = itt + 1 scheduler1.step() scheduler2.step() unet.train() D.train() for p in unet.parameters(): p.requires_grad = False for p in D.parameters(): p.requires_grad = True if alpha > 0: for t in range(n_critic): (in_images, out_images, pat) = next(gen) in_images = in_images.cuda(0) out_images = out_images.cuda(0)
model.eval() fixed_pred,_ = model(fixed_masked, fixed_mask) torchvision.utils.save_image(fixed_pred,os.path.join(results,f'pred_{i}.jpg'),normalize=True) print(fixed_pred.min(), fixed_pred.max(), fixed_pred.mean()) print(loss.item()) if not training: print(fixed_orig.min(), fixed_orig.max(), fixed_orig.mean()) print(fixed_masked.min(), fixed_masked.max(), fixed_masked.mean()) print(fixed_mask.min(), fixed_mask.max(), fixed_mask.mean()) torchvision.utils.save_image(fixed_masked, os.path.join(results, f'masked_{i}.jpg'),normalize=True) torchvision.utils.save_image(fixed_orig, os.path.join(results, f'orig_{i}.jpg'),normalize=True) save_image(0,fixed_masked, fixed_mask,False,torch.tensor(0)) for i in range(200): i += 1 print(f'{i}..') for [masked, mask], orig in dl: model.train() masked = masked.to(device) mask = mask.to(device) orig = orig.to(device) optimizer.zero_grad() pred, _ = model(masked, mask) loss = criterion(orig,mask,pred) loss.backward() optimizer.step() save_image(i,fixed_masked, fixed_mask,True, loss)
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
it = -1 for epoch in range(1000): for k, (data, lbl) in enumerate(trainloader): it += 1 print(it) data = data.cuda() lbl = lbl.cuda() data.requires_grad = True lbl.requires_grad = True optimizer.zero_grad() # zero the gradient buffers net.train() output = net(data) output = F.sigmoid(output) loss = dice_loss(output, lbl) ### tady spočíta MSE pro denoising.... loss.backward() ## claculate gradients optimizer.step() ## update parametrs clas = (output > 0.5).float() acc = torch.mean((clas == lbl).float()) train_acc_tmp.append(acc.detach().cpu().numpy()) train_loss_tmp.append(loss.detach().cpu().numpy())