def get_model(config): global is_cuda if not is_cuda: device = 'cpu' unet_model = m.Unet(drop_rate=0.4, bn_momentum=0.1, config=config) unet_model = unet_model.to(device) unet_model.load_state_dict(torch.load(config['trained_model'], map_location=lambda storage, loc: storage)) else: device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') unet_model = m.Unet(drop_rate=0.4, bn_momentum=0.1, config=config) unet_model = unet_model.to(device) unet_model.load_state_dict(torch.load(config['trained_model'])) return unet_model
def get_summary(config): device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') # vgg = models.vgg16().to(device) unet_model = m.Unet(drop_rate=0.4, bn_momentum=0.1, config=config) unet_model = unet_model.to(device) # import ipdb as pdb; pdb.set_trace() summary(unet_model, (1, 200, 200))
def build_model(self): """Creates and initializes the shared and controller models.""" if self.args.network_type == 'unet': self.shared = models.Unet(self.args) else: raise NotImplementedError(f'Network type ' f'`{self.args.network_type}` is not ' f'defined') self.controller = models.Controller(self.args) if self.args.num_gpu == 1: self.shared.cuda() self.controller.cuda() elif self.args.num_gpu > 1: raise NotImplementedError('`num_gpu > 1` is in progress')
print 'Create model' channels = 3 metrics = [jacc_coef] if model == 'vgg_unet': model = models.VGG16_Unet(height, width, pretrained=True, freeze_pretrained=False, loss=loss, optimizer=optimizer, metrics=[jacc_coef]) elif model == 'unet': model = models.Unet(height, width, loss=loss, optimizer=optimizer, metrics=metrics, fc_size=4096, channels=channels) elif model == 'unet2': model = models.Unet2(height, width, loss=loss, optimizer=optimizer, metrics=metrics, fc_size=4096, channels=channels) else: print "Incorrect model name"
def run_main(config): dataset_base_path = "./data/" target_path = natsorted(glob(dataset_base_path + '/mask/*.png')) image_paths = natsorted(glob(dataset_base_path + '/img/*.png')) target_val_path = natsorted(glob(dataset_base_path + '/val_mask/*.png')) image_val_path = natsorted(glob(dataset_base_path + '/val_img/*.png')) nih_dataset_train = EMdataset(image_paths=image_paths, target_paths=target_path) nih_dataset_val = EMdataset(image_paths=image_val_path, target_paths=target_val_path) #import ipdb as pdb; pdb.set_trace() train_loader = DataLoader(nih_dataset_train, batch_size=16, shuffle=True, num_workers=1) val_loader = DataLoader(nih_dataset_val, batch_size=16, shuffle=True, num_workers=1) model = m.Unet(drop_rate=0.4, bn_momentum=0.1, config=config) if config['operation_mode'].lower( ) == "retrain" or config['operation_mode'].lower() == "inference": print("Using a trained model...") model.load_state_dict(torch.load(config['trained_model'])) elif config["operation_mode"].lower() == "visualize": print("Using a trained model...") if cuda: model.load_state_dict(torch.load(config['trained_model'])) else: model.load_state_dict( torch.load(config['trained_model'], map_location='cpu')) v.visualize_model(model, config) return # import ipdb as pdb; pdb.set_trace() if cuda: model.cuda() print('gpu_activate') num_epochs = config["num_epochs"] initial_lr = config["lr"] experiment_path = config["log_output_dir"] + config['experiment_name'] output_image_dir = experiment_path + "/figs/" betas = torch.linspace(3.0, 8.0, num_epochs) # criterion = nn.BCELoss() optimizer = optim.Adam(model.parameters(), lr=initial_lr) scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, num_epochs) # import ipdb as pdb; pdb.set_trace() writer = SummaryWriter(log_dir=utility.get_experiment_dir(config)) best_score = 0 for epoch in tqdm(range(1, num_epochs + 1)): start_time = time.time() scheduler.step() lr = scheduler.get_lr()[0] model.beta = betas[epoch - 1] # for ternary net, set beta writer.add_scalar('learning_rate', lr, epoch) model.train() train_loss_total = 0.0 num_steps = 0 capture = True for i, batch in enumerate(train_loader): input_samples, gt_samples = batch[0], batch[1] if cuda: var_input = input_samples.cuda() var_gt = gt_samples.cuda() else: var_input = input_samples var_gt = gt_samples preds = model(var_input) loss = dice_loss(preds, var_gt) # import ipdb as pdb; pdb.set_trace() var_gt = var_gt.float() train_loss_total += loss.item() optimizer.zero_grad() loss.backward() optimizer.step() num_steps += 1 if epoch % 1 == 0 and capture: capture = False input_samples, gt_samples = get_samples( image_val_path, target_val_path, 4) if cuda: input_samples = input_samples.cuda() preds = model(input_samples) input_samples = input_samples.data.cpu().numpy() preds = preds.data.cpu().numpy() # import ipdb as pdb; pdb.set_trace() save_image(input_samples[0][0], gt_samples[0][0], preds[0][0], epoch, 0, output_image_dir) train_loss_total_avg = train_loss_total / num_steps # import ipdb as pdb; pdb.set_trace() model.eval() val_loss_total = 0.0 num_steps = 0 metric_fns = [ dice_score, hausdorff_score, precision_score, recall_score, specificity_score, intersection_over_union, accuracy_score ] metric_mgr = MetricManager(metric_fns) for i, batch in enumerate(val_loader): input_samples, gt_samples = batch[0], batch[1] with torch.no_grad(): if cuda: var_input = input_samples.cuda() var_gt = gt_samples.cuda(async=True) else: var_input = input_samples var_gt = gt_samples preds = model(var_input) loss = dice_loss(preds, var_gt) # loss = criterion(preds, var_gt) # loss = weighted_bce_loss(preds, var_gt, 0.5, 2.5) val_loss_total += loss.item() gt_npy = gt_samples.data.cpu().numpy() #.astype(np.uint8) gt_npy = gt_npy.squeeze(axis=1) preds = preds.data.cpu().numpy() preds = threshold_predictions(preds) # preds = preds.astype(np.uint8) preds = preds.squeeze(axis=1) metric_mgr(preds, gt_npy) num_steps += 1 metrics_dict = metric_mgr.get_results() metric_mgr.reset() writer.add_scalars('metrics', metrics_dict, epoch) val_loss_total_avg = val_loss_total / num_steps writer.add_scalars('losses', { 'val_loss': val_loss_total_avg, 'train_loss': train_loss_total_avg }, epoch) end_time = time.time() total_time = end_time - start_time msg = "Epoch {} took {:.2f} seconds dice_score={}. precision={} iou={} loss_train={} val_loss={}".format( epoch, total_time, metrics_dict["dice_score"], metrics_dict["precision_score"], metrics_dict["intersection_over_union"], train_loss_total_avg, val_loss_total_avg) utility.log_info(config, msg) tqdm.write(msg) writer.add_scalars('losses', {'train_loss': train_loss_total_avg}, epoch) if metrics_dict["dice_score"] > best_score: best_score = metrics_dict["dice_score"] utility.save_model(model=model, config=config) if not (config['operation_mode'].lower() == "inference"): utility.save_model(model=model, config=config)
'fc2': 'categorical_crossentropy', }, loss_weights={ 'conv7': 1., 'fc2': 0., }, metrics={ 'conv7': custom_metric, #'fc2': 'categorical_accuracy', }) monitor_metric = 'val_conv7_jacc_coef' #only when multi-output it will be like ._conv7_. elif model_type == 'unet': model = models.Unet(height, width, custom_loss=custom_loss, optimizer=optimizer, custom_metrics=custom_metric, fc_size=fc_size, channels=channels) monitor_metric = 'val_jacc_coef' elif model_type == 'unet2': model = models.Unet2(height, width, custom_loss=custom_loss, optimizer=optimizer, custom_metrics=custom_metric, fc_size=fc_size, channels=channels) monitor_metric = 'val_jacc_coef' elif model_type == 'vgg': VGG16_WEIGHTS_NOTOP = project_path + 'pretrained_weights/vgg16_notop.h5'
help='output model file') parser.add_argument("--batch-size", type=int, default=16, help='batch size') args = parser.parse_args() # directory = Path(args.input) # files = [f for f in directory.iterdir() if f.suffix == ".pth"] files = glob.glob(args.input + "/stage1/checkpoints/stage1.*.pth") files += glob.glob(args.input + "/stage2/checkpoints/stage1.*.pth") assert (len(files) > 1) net = models.Unet( encoder_name="resnet34", activation='sigmoid', classes=1, # center=True ) checkpoint = torch.load(files[0]) net.load_state_dict(checkpoint['model_state_dict']) for i, f in enumerate(files[1:]): # net2 = model.load(f) net2 = models.Unet( encoder_name="resnet34", activation='sigmoid', classes=1, # center=True ) checkpoint = torch.load(f) net2.load_state_dict(checkpoint['model_state_dict'])
def get_model(config): device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') unet_model = m.Unet(drop_rate=0.4, bn_momentum=0.1, config=config) unet_model = unet_model.to(device) unet_model.load_state_dict(torch.load(config['trained_model'])) return unet_model
initial_lr = 0.001 num_epochs = 550 opt_loss = 10000 def threshold(array): array = (array > 0.89) * 1.0 return array # print(torch.cuda.is_available()) # print(torch.cuda.current_device()) dirr = '/home/eljurros/spare-workplace/Multi_Organ_Segmentation/DataSet' if model_type == 'Unet': model = models.Unet(drop_rate=0.4, bn_momentum=0.1) model = torch.load( '/home/eljurros/Desktop/myria_scripts/checkpnt_BEST.ckpt') elif model_type == 'BB_Unet': model = models.BB_Unet(drop_rate=0.4, bn_momentum=0.1) optimizer = optim.Adam(model.parameters(), lr=initial_lr) scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, num_epochs) train_transform = None txt_file_path = '../Multi_Organ_Segmentation/results_MO_newest_edition_2.txt' dice = organ_0 = organ_1 = organ_2 = organ_3 = 0 start_time = time.time() dataset = DataSEt_Classes.SegTHor_2D_TrainDS(dirr,
def run_main(config): train_transform = transforms.Compose([ CenterCrop2D((200, 200)), ElasticTransform(alpha_range=(28.0, 30.0), sigma_range=(3.5, 4.0), p=0.3), RandomAffine(degrees=4.6, scale=(0.98, 1.02), translate=(0.03, 0.03)), RandomTensorChannelShift((-0.10, 0.10)), ToTensor(), NormalizeInstance(), ]) val_transform = transforms.Compose([ CenterCrop2D((200, 200)), ToTensor(), NormalizeInstance(), ]) # import ipdb as pdb; pdb.set_trace() dataset_base_path = "/export/tmp/hemmat/datasets/em_challenge/" target_path = natsort.natsorted(glob.glob(dataset_base_path + 'mask/*.PNG')) image_paths = natsort.natsorted(glob.glob(dataset_base_path + 'data/*.PNG')) target_val_path = natsort.natsorted( glob.glob(dataset_base_path + 'val_mask/*.PNG')) image_val_path = natsort.natsorted( glob.glob(dataset_base_path + 'val_img/*.PNG')) gmdataset_train = EMdataset(image_paths=image_paths, target_paths=target_path) gmdataset_val = EMdataset(image_paths=image_val_path, target_paths=target_val_path) train_loader = DataLoader(gmdataset_train, batch_size=5, shuffle=True, num_workers=1) val_loader = DataLoader(gmdataset_val, batch_size=4, shuffle=True, num_workers=1) utility.create_log_file(config) utility.log_info( config, "{0}\nStarting experiment {1}\n{0}\n".format( 50 * "=", utility.get_experiment_name(config))) # import ipdb as pdb; pdb.set_trace() model = m.Unet(drop_rate=0.4, bn_momentum=0.1, config=config) if config['operation_mode'].lower( ) == "retrain" or config['operation_mode'].lower() == "inference": print("Using a trained model...") model.load_state_dict(torch.load(config['trained_model'])) elif config["operation_mode"].lower() == "visualize": print("Using a trained model...") if cuda: model.load_state_dict(torch.load(config['trained_model'])) else: model.load_state_dict( torch.load(config['trained_model'], map_location='cpu')) mv.visualize_model(model, config) return # import ipdb as pdb; pdb.set_trace() if cuda: model.cuda() num_epochs = config["num_epochs"] initial_lr = config["lr"] experiment_path = config["log_output_dir"] + config['experiment_name'] output_image_dir = experiment_path + "/figs/" betas = torch.linspace(3.0, 8.0, num_epochs) optimizer = optim.Adam(model.parameters(), lr=initial_lr) # scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, num_epochs) lr_milestones = range(0, int(num_epochs), int(int(num_epochs) / 5)) lr_milestones = lr_milestones[1:] scheduler = optim.lr_scheduler.MultiStepLR(optimizer, milestones=lr_milestones, gamma=0.1) # import ipdb as pdb; pdb.set_trace() writer = SummaryWriter(log_dir=utility.get_experiment_dir(config)) best_dice = 0 for epoch in tqdm(range(1, num_epochs + 1)): start_time = time.time() scheduler.step() lr = scheduler.get_lr()[0] model.beta = betas[epoch - 1] # for ternary net, set beta writer.add_scalar('learning_rate', lr, epoch) model.train() train_loss_total = 0.0 num_steps = 0 capture = True for i, batch in enumerate(train_loader): #import ipdb as pdb; pdb.set_trace() input_samples, gt_samples, idx = batch[0], batch[1], batch[2] if cuda: var_input = input_samples.cuda() var_gt = gt_samples.cuda(async=True) var_gt = var_gt.float() else: var_input = input_samples var_gt = gt_samples var_gt = var_gt.float() preds = model(var_input) # import ipdb as pdb; pdb.set_trace() loss = calc_loss(preds, var_gt) train_loss_total += loss.item() optimizer.zero_grad() loss.backward() optimizer.step() num_steps += 1 if epoch % 5 == 0 and capture: capture = False input_samples, gt_samples = get_samples( image_val_path, target_val_path, 4) if cuda: input_samples = input_samples.cuda() preds = model(input_samples) input_samples = input_samples.data.cpu().numpy() preds = preds.data.cpu().numpy() # import ipdb as pdb; pdb.set_trace() save_image(input_samples[0][0], gt_samples[0][0], preds[0][0], epoch, 0, output_image_dir) train_loss_total_avg = train_loss_total / num_steps # import ipdb as pdb; pdb.set_trace() model.train() val_loss_total = 0.0 num_steps = 0 metric_fns = [ dice_score, hausdorff_score, precision_score, recall_score, specificity_score, intersection_over_union, accuracy_score, rand_index_score ] metric_mgr = MetricManager(metric_fns) for i, batch in enumerate(val_loader): # input_samples, gt_samples = batch[0], batch[1] input_samples, gt_samples, idx = batch[0], batch[1], batch[2] with torch.no_grad(): if cuda: var_input = input_samples.cuda() var_gt = gt_samples.cuda(async=True) var_gt = var_gt.float() else: var_input = input_samples var_gt = gt_samples var_gt = var_gt.float() # import ipdb as pdb; pdb.set_trace() preds = model(var_input) loss = dice_loss(preds, var_gt) val_loss_total += loss.item() # Metrics computation gt_npy = gt_samples.numpy().astype(np.uint8) gt_npy = gt_npy.squeeze(axis=1) preds = preds.data.cpu().numpy() preds = threshold_predictions(preds) preds = preds.astype(np.uint8) preds = preds.squeeze(axis=1) metric_mgr(preds, gt_npy) #save_image(input_samples[0][0], preds[0], gt_samples, epoch, idx[0]) # save_pred(model, image_val_path, epoch, output_image_dir) num_steps += 1 metrics_dict = metric_mgr.get_results() metric_mgr.reset() writer.add_scalars('metrics', metrics_dict, epoch) # import ipdb as pdb; pdb.set_trace() val_loss_total_avg = val_loss_total / num_steps writer.add_scalars('losses', { 'val_loss': val_loss_total_avg, 'train_loss': train_loss_total_avg }, epoch) end_time = time.time() total_time = end_time - start_time # import ipdb as pdb; pdb.set_trace() log_str = "Epoch {} took {:.2f} seconds train_loss={} dice_score={} rand_index_score={} lr={}.".format( epoch, total_time, train_loss_total_avg, metrics_dict["dice_score"], metrics_dict["rand_index_score"], get_lr(optimizer)) utility.log_info(config, log_str) tqdm.write(log_str) writer.add_scalars('losses', {'train_loss': train_loss_total_avg}, epoch) if metrics_dict["dice_score"] > best_dice: best_dice = metrics_dict["dice_score"] utility.save_model(model=model, config=config) if not (config['operation_mode'].lower() == "inference"): utility.save_model(model=model, config=config)