def convert_save(path, name, ckpth, image): model = Unet() model.load_state_dict(torch.load(os.path.join(ckpth, 'Generator.pth'))) output_image = model(image).squeeze(0).detach().numpy() output_image = np.moveaxis(output_image, 0, 2) output_image = output_image * np.array((0.5, 0.5, 0.5)) + \ np.array((0.5, 0.5, 0.5)) output_image = np.clip(output_image, 0, 1) output_image = Image.fromarray(np.uint8(output_image * 255)) output_image.save(os.path.join(path, name))
def test_unet(): data = mnist_data() backbone = ResNet() # preds = backbone(data.get_test()[0]) gen = Unet() # input_shape = gen.get_input_shape() # print(gen.get_output_shape()) rand_data_shape = (50, 28, 28, 1) random_noise_data = np.random.normal(size=rand_data_shape) # import pdb; pdb.set_trace() # breakpoint 7e7a66fc // preds = gen.predict(random_noise_data) return True
def _build_training(self): # Unet self.output = Unet(name="UNet", in_data=self.input_data, reuse=False) # loss. # self.loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits( # labels=self.input_masks, logits=self.output)) # self.loss = tf.reduce_mean(tf.squared_difference(self.input_masks, # self.output)) # Use Tensorflow and Keras at the same time. self.loss = tf.reduce_mean( tf.keras.losses.binary_crossentropy(self.input_masks, self.output)) # optimizer self.opt = tf.train.AdamOptimizer(learning_rate=self.lr).minimize( self.loss, name="opt") # summary tf.summary.scalar('loss', self.loss) self.summary = tf.summary.merge_all() # summary and checkpoint self.writer = tf.summary.FileWriter(self.summary_dir, graph=self.sess.graph) self.saver = tf.train.Saver(max_to_keep=10, name=self.saver_name) self.summary_proto = tf.Summary()
def test(args): # device device = torch.device("cuda:%d" % args.gpu if torch.cuda.is_available() else "cpu") torch.backends.cudnn.benchmark = True # data testset = SonyTestDataset(args.input_dir, args.gt_dir) test_loader = DataLoader(testset, batch_size=args.batch_size, shuffle=False, num_workers=args.num_workers) # model model = Unet() model.load_state_dict(torch.load(args.model)) model.to(device) model.eval() # testing for i, databatch in tqdm(enumerate(test_loader), total=len(test_loader)): input_full, scale_full, gt_full, test_id, ratio = databatch scale_full, gt_full = torch.squeeze(scale_full), torch.squeeze(gt_full) # processing inputs = input_full.to(device) outputs = model(inputs) outputs = outputs.cpu().detach() outputs = torch.squeeze(outputs) outputs = outputs.permute(1, 2, 0) # scaling can clipping outputs, scale_full, gt_full = outputs.numpy(), scale_full.numpy( ), gt_full.numpy() scale_full = scale_full * np.mean(gt_full) / np.mean( scale_full ) # scale the low-light image to the same mean of the ground truth outputs = np.minimum(np.maximum(outputs, 0), 1) # saving if not os.path.isdir(os.path.join(args.result_dir, 'eval')): os.makedirs(os.path.join(args.result_dir, 'eval')) scipy.misc.toimage( scale_full * 255, high=255, low=0, cmin=0, cmax=255).save( os.path.join( args.result_dir, 'eval', '%05d_00_train_%d_scale.jpg' % (test_id[0], ratio[0]))) scipy.misc.toimage( outputs * 255, high=255, low=0, cmin=0, cmax=255).save( os.path.join( args.result_dir, 'eval', '%05d_00_train_%d_out.jpg' % (test_id[0], ratio[0]))) scipy.misc.toimage( gt_full * 255, high=255, low=0, cmin=0, cmax=255).save( os.path.join( args.result_dir, 'eval', '%05d_00_train_%d_gt.jpg' % (test_id[0], ratio[0])))
def _build_test(self): # network. output = Unet(name="UNet", in_data=self.input_data, reuse=False) self.saver = tf.train.Saver(max_to_keep=10, name=self.saver_name) # define saver, after the network! return output
def main(): if opt.is_continue: model = torch.load('unet.pth').to(device) else: model = Unet(19).to(device) dataset = Cityscapes(opt.root, resize=opt.resize, crop=opt.crop) dataloader = DataLoader(dataset, batch_size=opt.batch_size, shuffle=True, num_workers=1) criterion = BCELoss().to(device) optimizer = Adam(model.parameters(), lr=0.001) t_now = time.time() for epoch in range(opt.n_epochs): print('epoch {}'.format(epoch)) for i, batch in enumerate(dataloader): inputs, labels = batch inputs = inputs.to(device) labels = labels.to(device) optimizer.zero_grad() outputs = model(inputs) loss = criterion(outputs, labels) loss.backward() optimizer.step() if i % 100 == 0: print(loss) print('time:', time.time() - t_now) t_now = time.time() print(loss) torch.save(model, 'unet.pth')
def test(args): # device device = torch.device("cuda:%d" % args.gpu if torch.cuda.is_available() else "cpu") torch.backends.cudnn.benchmark = True # images path fns = glob.glob(path.join(args.imgdir, '*.DNG')) n = len(fns) # model model = Unet() model.load_state_dict(torch.load(args.model)) model.to(device) model.eval() # ratio ratio = 200 for idx in range(n): fn = fns[idx] print(fn) raw = rawpy.imread(fn) input = np.expand_dims(pack_raw(raw), axis=0) * ratio scale_full = np.expand_dims(np.float32(input / 65535.0), axis=0) input = crop_center(input, 1024, 1024) input = torch.from_numpy(input) input = torch.squeeze(input) input = input.permute(2, 0, 1) input = torch.unsqueeze(input, dim=0) input = input.to(device) outputs = model(input) outputs = outputs.cpu().detach() outputs = torch.squeeze(outputs) outputs = outputs.permute(1, 2, 0) outputs = outputs.numpy() outputs = np.minimum(np.maximum(outputs, 0), 1) scale_full = torch.from_numpy(scale_full) scale_full = torch.squeeze(scale_full) scipy.misc.toimage(outputs * 255, high=255, low=0, cmin=0, cmax=255).save( path.join(args.imgdir, path.basename(fn) + '_out.jpg'))
def _build_training(self): """ 定义self.loss,self.opt,self.summary,self.writer,self.saver """ self.output = Unet(name="UNet", in_data=self.input_data, reuse=False) # loss. softmax交叉熵函数。 损失函数用来衡量网络准确性,提高预测精度并减少误差,损失函数越小越好。 self.loss = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(labels=self.input_masks, logits=self.output)) # self.loss = tf.reduce_mean(tf.squared_difference(self.input_masks, # self.output)) # Use Tensorflow and Keras at the same time. # self.loss = tf.reduce_mean(tf.keras.losses.binary_crossentropy( # self.input_masks, self.output)) # 准确率计算 20191111添加 # tf.equal()返回一个bool值,两参数相等时返回1 , tf.argmax()就是返回最大的那个数值所在的下标 , tf.cast()转换数据类型 correct_prediction = tf.equal(self.input_masks, self.output) self.acc = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) # optimizer # 定义Adam优化器,是一个寻找全局最优点的优化算法,引入了二次方梯度校正 # Adam的优点主要在于经过偏置校正后,每一次迭代学习率都有个确定范围,使得参数比较平稳。 self.opt = tf.train.AdamOptimizer(learning_rate=self.lr).minimize( self.loss, name="opt") # summary 用来显示标量信息 tf.summary.scalar("acc", self.acc) # 20191111添加 tf.summary.scalar("loss", self.loss) # 添加一个操作,代表执行所有summary操作,这样可以避免人工执行每一个summary op。 self.summary = tf.summary.merge_all() # summary and checkpoint 用于将Summary写入磁盘,需要制定存储路径logdir # 如果传递了Graph对象,则在Graph Visualization会显示Tensor Shape Information。执行summary op后,将返回结果传递给add_summary()方法即可。 self.writer = tf.summary.FileWriter(self.summary_dir, graph=self.sess.graph) # 最多保存10个最新的checkpoint文件 , tf.train.Saver()用来保存tensorflow训练模型的,默认保存全部参数 self.saver = tf.train.Saver(max_to_keep=10, name=self.saver_name) self.summary_proto = tf.Summary()
def train(lr, patch_size, n_classes, epochs, gpuid, model_name, batch_size): if model_name == "Unet": model = Unet.Unet(input_size=(patch_size, patch_size, 3), classes=n_classes) elif model_name == "Linknet": model_c = Linknet.Linknet(n_classes) model = model_c.base((patch_size, patch_size, 3)) elif model_name == "ResUnet": model_c = ResUnet.ResUnet() model = model_c.base((patch_size, patch_size, 3), n_classes) else: model_c = proposedCNN.proposedCnn() model = model_c.base((patch_size, patch_size, 3), n_classes) x_train = HDF5Matrix("table_train.pytable", 'img') y_train = HDF5Matrix("table_train.pytable", 'mask') x_val = HDF5Matrix("table_val.pytable", 'img') y_val = HDF5Matrix("table_val.pytable", 'mask') os.environ['CUDA_VISIBLE_DEVICES'] = gpuid path = "checkpoint.hdf5" optimizer = Adam(lr=lr) checkpoint = ModelCheckpoint(filepath=path, monitor='val_loss', verbose=1, save_best_only=True) earlystopping = EarlyStopping(monitor='val_loss', patience=10, verbose=1) model.compile(optimizer=optimizer, loss='categorical_crossentropy' if n_classes > 1 else 'binary_crossentropy', metrics=['acc']) model.fit(x=x_train, y=y_train, batch_size=batch_size, epochs=epochs, callbacks=[checkpoint, earlystopping], validation_data=(x_val, y_val), shuffle="batch") model.load_weights(path) model.save(model_name + " segmentation.hdf5")
def _build_test(self): # network. output = Unet(name="UNet", in_data=self.input_data, reuse=False) test_prediction = tf.equal(tf.argmax(self.input_data, 1), tf.argmax(output, 1)) self.acc = tf.reduce_mean(tf.cast(test_prediction, tf.float32)) # summary 用来显示标量信息 tf.summary.scalar("acc", self.acc) self.summary = tf.summary.merge_all() self.writer = tf.summary.FileWriter(self.summary_dir, graph=self.sess.graph) # 最多保存10个最新的checkpoint文件 , tf.train.Saver()用来保存tensorflow训练模型的,默认保存全部参数 self.saver = tf.train.Saver(max_to_keep=10, name=self.saver_name) self.summary_proto = tf.Summary() # define saver, after the network! return output
def _build_training(self): self.output = Unet(name="UNet", in_data=self.input_data, reuse=False) # loss self.loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits( labels=self.input_masks, logits=self.output)) # 定义Adam优化器 self.opt = tf.train.AdamOptimizer(learning_rate=self.lr).minimize(self.loss, name="opt") # summary tf.summary.scalar('loss', self.loss) self.summary = tf.summary.merge_all() self.writer = tf.summary.FileWriter( self.summary_dir, graph=self.sess.graph) self.saver = tf.train.Saver(max_to_keep=10, name=self.saver_name) self.summary_proto = tf.Summary()
def getModelsandData(path, batch_size, device): netD = PatchGAN() netG = Unet() apply_weights(netD) apply_weights(netG) device = torch.device(device) transform = transforms.Compose([ transforms.Resize((286, 572)), RandomCropMap(256), transforms.ToTensor(), transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5]) ]) dataset = MapDataset(path, transform=transform) dataloader = torch.utils.data.DataLoader(dataset, batch_size=batch_size, shuffle=True) return netD, netG, dataloader, device
def test_unet_model(self): image = Raster \ .read \ .format("geotiff") \ .load(TEST_IMAGE_PATH) label: Raster = Raster \ .read \ .format("shp") \ .options( pixel=image.pixel, extent=image.extent ) \ .load(self.shape_path) standarize1 = ImageStand(raster=image) standarized = standarize1.standarize_image(StandardScaler()) raster_data = RasterData(standarized, label) unet_images = raster_data.prepare_unet_data(image_size=[64, 64]) callbacks = [ EarlyStopping(patience=100, verbose=1), ReduceLROnPlateau(factor=0.1, patience=100, min_lr=0, verbose=1), ModelCheckpoint('model_more_class_pixels.h5', verbose=1, save_best_only=True, save_weights_only=False) ] config = UnetConfig( input_size=[64, 64, 3], metrics=["accuracy"], optimizer=SGD(lr=0.001), callbacks=callbacks, loss="binary_crossentropy", ) # unet = Unet(config=config) unet.compile() unet.fit(unet_images, epochs=1) predicted = unet.predict(x=unet_images.x_test[0], threshold=0.4) SubPlots().extend(predicted, unet_images.x_test[0]).plot(nrows=1)
def run_model(): # Running the model dataset = CD_Dataset(path=DATASET_PATH, download=True, fit=False, num_classes=OUTPUT_CHANNELS[0]) dataset.mean_features = np.array([0.5, 0.5, 0.5]) dataset.std_features = np.array([0.5, 0.5, 0.5]) INPUT_PATCH_SIZE = [SPATCH, SPATCH] model_input_size = INPUT_PATCH_SIZE + INPUT_CHANNELS if MODEL == MIMO: MODEL_PATH_NAME = 'MIMO_' + MODEL_PATH_NAME model = MimoNet(model_input_size, classes=OUTPUT_CHANNELS[0], regularized=True) elif MODEL == UNET: MODEL_PATH_NAME = 'UNET_' + MODEL_PATH_NAME model = Unet(model_input_size, classes=OUTPUT_CHANNELS[0], regularized=True) else: print('CHOOSE MODEL: 0:MIMO, 1:UNET') sys.exit(0) if LOAD_MODEL: print("loading model " + MODEL_PATH_NAME + " from disk.") model.load_model(MODEL_PATH_NAME) if MODEL_TRAINING_SESSION: print("trainig model") train(model, dataset, epochs=EPOCHS, n_batch=N_PATCH_BATCH, use_weights=True, name=MODEL_PATH_NAME) print("saving model " + MODEL_PATH_NAME + " to disk.")
def main(): args = parser.parse_args() step = 0 exp_name = f'{args.name}_{hp.max_lr}_{hp.cycle_length}' transforms = segtrans.JointCompose([segtrans.Resize(400), segtrans.RandomRotate(0, 90), segtrans.RandomCrop(256, 256), segtrans.ToTensor(), segtrans.Normalize(mean=hp.mean, std=hp.std)]) val_transforms = segtrans.JointCompose([segtrans.PadToFactor(), segtrans.ToTensor(), segtrans.Normalize(mean=hp.mean, std=hp.std)]) train_dataset = DSBDataset(f'{args.data}/train', transforms=transforms) val_dataset = DSBDataset(f'{args.data}/val', transforms=val_transforms) model = Unet() if args.checkpoint: checkpoint = torch.load(args.checkpoint) model.load_state_dict(checkpoint['state']) step = checkpoint['step'] exp_name = checkpoint['exp_name'] optimizer = Adam(model.parameters(), lr=hp.max_lr) if args.find_lr: scheduler = LRFinderScheduler(optimizer) else: scheduler = SGDRScheduler(optimizer, min_lr=hp.min_lr, max_lr=hp.max_lr, cycle_length=hp.cycle_length, current_step=step) model.cuda(device=args.device) train(model, optimizer, scheduler, train_dataset, val_dataset, n_epochs=args.epochs, batch_size=args.batch_size, exp_name=exp_name, device=args.device, step=step)
file_name = '../submission.csv' with open(file_name, 'a+') as f: for i in range(mask_preds.shape[0]): s = str(i + 1 + start) + ',' + rles[i] f.write(s + '\n') start += mask_preds.shape[0] file_name = '../submission.csv' with open(file_name, 'a+') as f: f.write('img,pixels\n') # Load saved model model = Unet(1, add_residual=True) model.load_state_dict(torch.load('./saved_model')) # Load trained model if use_cuda and torch.cuda.is_available(): model.cuda() transforms_valid = A.Compose([ A.Resize(height=512, width=512, p=1.0), # A.Normalize(mean=(0),std=(255),p=1.0), ToTensorV2(p=1.0), ]) sub = pd.read_csv('../data-samples/sample_submission.csv') sub_data = Ultrasound_Dataset( sub, transform=transforms_valid) # Same Transform as in validation
def main(args): data_path = '/home/birgit/MA/Code/torchmeta/gitlab/data' with open(args.config, 'r') as f: config = json.load(f) if args.folder is not None: config['folder'] = args.folder if args.num_steps > 0: config['num_steps'] = args.num_steps if args.num_batches > 0: config['num_batches'] = args.num_batches device = torch.device( 'cuda' if args.use_cuda and torch.cuda.is_available() else 'cpu') loss_function = DiceLoss() dataset = 'pascal5i' fold = config['fold'] steps = config['num_adaption_steps'] padding = 1 if 'feature_scale' in config.keys(): model = Unet(feature_scale=config['feature_scale'], padding=padding) else: model = Unet(feature_scale=4, padding=padding) # get datasets and load into meta learning format meta_train_dataset, meta_val_dataset, meta_test_dataset = get_datasets( dataset, data_path, config['num_ways'], config['num_shots'], config['num_shots_test'], fold=fold, download=False, augment=False) meta_val_dataloader = BatchMetaDataLoader(meta_val_dataset, batch_size=config['batch_size'], shuffle=True, num_workers=args.num_workers, pin_memory=True) print('num shots = ', config['num_shots']) print(f'Using device: {device}') with open(config['model_path'], 'rb') as f: model.load_state_dict(torch.load(f, map_location=device)) metalearner = ModelAgnosticMetaLearning(model, first_order=config['first_order'], num_adaptation_steps=steps, step_size=config['step_size'], loss_function=loss_function, device=device) results = metalearner.evaluate(meta_val_dataloader, max_batches=config['num_batches'], verbose=args.verbose, desc='Test', is_test=True) if dataset == 'pascal5i': labels = [ 'aeroplane', 'bike', 'bird', 'boat', 'bottle', 'bus', 'car', 'cat', 'chair', 'cow', 'dining table', 'dog', 'horse', 'motorbike', 'person', 'pottedplant', 'sheep', 'sofa', 'train', 'tvmonitor' ] accuracies = [ value for _, value in results['mean_acc_per_label'].items() ] ious = [value for _, value in results['mean_iou_per_label'].items()] val_ious = [x for x in ious if x > 0.0] val_accs = [x for x in accuracies if x > 0.0] y_pos = np.arange(len(labels)) fig, (ax1, ax2) = plt.subplots(1, 2) ax1.barh(y_pos, accuracies, align='center', alpha=0.5) ax1.set_yticks(y_pos) ax1.set_yticklabels(labels) ax1.set_xlabel('acc') ax1.set_xlim(0, 1) ax1.set_title('Accuracies per label') ax2.barh(y_pos, ious, align='center', alpha=0.5) ax2.set_yticks(y_pos) ax2.set_yticklabels(labels) ax2.set_xlabel('iou') ax2.set_xlim(0, 1) ax2.set_title('IoU scores per label') plt.grid(True) plt.show() # Save results dirname = os.path.dirname(config['model_path']) with open(os.path.join(dirname, 'test_results.json'), 'w') as f: json.dump(results, f)
lr = 0.0005 weight_decay = 5e-5 lr_schedule = 0.985 def adjust_lr(optimizer, current_lr, schedule): current_lr = current_lr * schedule for param_group in optimizer.param_groups: param_group['lr'] = current_lr return current_lr if __name__ == "__main__": args, unparsed = config.get_args() model = Unet(args) model = model.cuda() model.train() optimizer = torch.optim.Adam(model.parameters(), lr=lr, weight_decay=weight_decay) loss = MulticlassDiceLoss() train = get_file_list(brats_preprocessed_folder, train_ids_path) val = get_file_list(brats_preprocessed_folder, valid_ids_path) shapes = [brats_dataloader.load_patient(i)[0].shape[1:] for i in train] max_shape = np.max(shapes, 0) max_shape = list(np.max((max_shape, patch_size), 0)) dataloader_train = brats_dataloader(train,
from skimage.transform import resize from medpy.io import load import numpy as np #import cv2 import nibabel as nib from PIL import Image from utils import dice_coef_loss, dice_coef, one_hot_encode, standardize #checkpoint = ModelCheckpoint('new/weights.h5', monitor='val_loss', verbose=1, save_best_only=True, mode='min') #earlystopping = EarlyStopping(monitor = 'val_loss', verbose = 1,min_delta = 0.01, patience = 3, mode = 'min') #callbacks_list = [checkpoint, earlystopping] input_img = Input((240, 240, 4)) model = Unet(input_img, 16, 0.1, True) learning_rate = 0.001 epochs = 5000 decay_rate = learning_rate / epochs model.compile(optimizer=Adam(lr=learning_rate, decay=decay_rate), loss=dice_coef_loss, metrics=[dice_coef]) model.summary() # data preprocessing starts here path = '../BRATS2017/Brats17TrainingData/HGG' all_images = os.listdir(path) #print(len(all_images)) all_images.sort() data = np.zeros((240, 240, 155, 4)) x_to = []
def main(args): logging.basicConfig(level=logging.DEBUG if args.verbose else logging.INFO) device = torch.device( 'cuda' if args.use_cuda and torch.cuda.is_available() else 'cpu') # Create output folder if (args.output_folder is not None): if not os.path.exists(args.output_folder): os.makedirs(args.output_folder) logging.debug('Creating folder `{0}`'.format(args.output_folder)) output_folder = os.path.join(args.output_folder, time.strftime('%Y-%m-%d_%H%M%S')) os.makedirs(output_folder) logging.debug('Creating folder `{0}`'.format(output_folder)) args.datafolder = os.path.abspath(args.datafolder) args.model_path = os.path.abspath( os.path.join(output_folder, 'model.th')) # Save the configuration in a config.json file with open(os.path.join(output_folder, 'config.json'), 'w') as f: json.dump(vars(args), f, indent=2) logging.info('Saving configuration file in `{0}`'.format( os.path.abspath(os.path.join(output_folder, 'config.json')))) # Get datasets and load into meta learning format meta_train_dataset, meta_val_dataset, _ = get_datasets( args.dataset, args.datafolder, args.num_ways, args.num_shots, args.num_shots_test, augment=augment, fold=args.fold, download=download_data) meta_train_dataloader = BatchMetaDataLoader(meta_train_dataset, batch_size=args.batch_size, shuffle=True, num_workers=args.num_workers, pin_memory=True) meta_val_dataloader = BatchMetaDataLoader(meta_val_dataset, batch_size=args.batch_size, shuffle=True, num_workers=args.num_workers, pin_memory=True) # Define model model = Unet(device=device, feature_scale=args.feature_scale) model = model.to(device) print(f'Using device: {device}') # Define optimizer meta_optimizer = torch.optim.Adam(model.parameters(), lr=args.meta_lr) #, weight_decay=1e-5) #meta_optimizer = torch.optim.RMSprop(model.parameters(), lr=learning_rate, momentum = 0.99) # Define meta learner metalearner = ModelAgnosticMetaLearning( model, meta_optimizer, first_order=args.first_order, num_adaptation_steps=args.num_adaption_steps, step_size=args.step_size, learn_step_size=False, loss_function=loss_function, device=device) best_value = None # Training loop epoch_desc = 'Epoch {{0: <{0}d}}'.format(1 + int(math.log10(args.num_epochs))) train_losses = [] val_losses = [] train_ious = [] train_accuracies = [] val_accuracies = [] val_ious = [] start_time = time.time() for epoch in range(args.num_epochs): print('start epoch ', epoch + 1) print('start train---------------------------------------------------') train_loss, train_accuracy, train_iou = metalearner.train( meta_train_dataloader, max_batches=args.num_batches, verbose=args.verbose, desc='Training', leave=False) print(f'\n train accuracy: {train_accuracy}, train loss: {train_loss}') print('end train---------------------------------------------------') train_losses.append(train_loss) train_accuracies.append(train_accuracy) train_ious.append(train_iou) # Evaluate in given intervals if epoch % args.val_step_size == 0: print( 'start evaluate-------------------------------------------------' ) results = metalearner.evaluate(meta_val_dataloader, max_batches=args.num_batches, verbose=args.verbose, desc=epoch_desc.format(epoch + 1), is_test=False) val_acc = results['accuracy'] val_loss = results['mean_outer_loss'] val_losses.append(val_loss) val_accuracies.append(val_acc) val_ious.append(results['iou']) print( f'\n validation accuracy: {val_acc}, validation loss: {val_loss}' ) print( 'end evaluate-------------------------------------------------' ) # Save best model if 'accuracies_after' in results: if (best_value is None) or (best_value < results['accuracies_after']): best_value = results['accuracies_after'] save_model = True elif (best_value is None) or (best_value > results['mean_outer_loss']): best_value = results['mean_outer_loss'] save_model = True else: save_model = False if save_model and (args.output_folder is not None): with open(args.model_path, 'wb') as f: torch.save(model.state_dict(), f) print('end epoch ', epoch + 1) elapsed_time = time.time() - start_time print('Finished after ', time.strftime('%H:%M:%S', time.gmtime(elapsed_time))) r = {} r['train_losses'] = train_losses r['train_accuracies'] = train_accuracies r['train_ious'] = train_ious r['val_losses'] = val_losses r['val_accuracies'] = val_accuracies r['val_ious'] = val_ious r['time'] = time.strftime('%H:%M:%S', time.gmtime(elapsed_time)) with open(os.path.join(output_folder, 'train_results.json'), 'w') as g: json.dump(r, g) logging.info('Saving results dict in `{0}`'.format( os.path.abspath(os.path.join(output_folder, 'train_results.json')))) # Plot results plot_errors(args.num_epochs, train_losses, val_losses, val_step_size=args.val_step_size, output_folder=output_folder, save=True, bce_dice_focal=bce_dice_focal) plot_accuracy(args.num_epochs, train_accuracies, val_accuracies, val_step_size=args.val_step_size, output_folder=output_folder, save=True) plot_iou(args.num_epochs, train_ious, val_ious, val_step_size=args.val_step_size, output_folder=output_folder, save=True) if hasattr(meta_train_dataset, 'close'): meta_train_dataset.close() meta_val_dataset.close()
def run_hyperparam(modelStr, numEpochs): # Hyperparameter search import itertools #--------------------------------------------- param_key = ['lr'] lr = [1e-1, 1e-2, 1e-3, 1e-4, 1e-5] #--------------------------------------------- #----set variables to emulate run_model()----- runMode = 'train' ckptDir = 'hyperparam_tmpckpt' if numEpochs == NUM_EPOCHS: numEpochs = NUM_EPOCHS_HYPERPARAM #--------------------------------------------- ps = [lr] params = list(itertools.product(*ps)) logDir, logName = createLog('_hyperparam') count = 0 best_val = 0 best_param = None for param in params: # build a new computational graph tf.reset_default_graph() input_sz = [IMG_DIM, IMG_DIM, 1] output_sz = [IMG_DIM, IMG_DIM, 3] curModel = Unet(input_sz, output_sz, verbose=False) curModel.create_model() curModel.metrics() count += 1 printSeparator('Running #%d of %d runs...' % (count, len(params))) print(getParamStr(param_key, param)) with tf.Session(config=GPU_CONFIG) as sess: # train the network dataset_filenames = getDataFileNames( TRAIN_DATA, excludeFnames=['.filepart', 'test']) for i in range(numEpochs): random.shuffle(dataset_filenames) train_loss = run_one_epoch(sess, curModel, dataset_filenames, modelStr, is_training=True) print('#%d training loss: %f' % (i, train_loss)) # run the trained network on the validation set dataset_filenames = getDataFileNames(VALIDATION_DATA) val_loss = run_one_epoch(sess, curModel, dataset_filenames, modelStr, is_training=False) logToFile( logName, 'train loss: %f, val loss: %f\n' % (train_loss, val_loss)) if best_val < val_loss: best_val = val_loss best_param = param logToFile(logName, 'Best validation accuracy: %f' % best_val) logToFile(logName, getParamStr(param_key, best_param))
def run_model(modelStr, runMode, ckptDir, dataDir, sampleDir, overrideCkpt, numEpochs): print('Running model...') # choose the correct dataset if dataDir == '': if runMode == 'train': dataDir = TRAIN_DATA elif runMode == 'test': dataDir = TEST_DATA elif runMode == 'val': dataDir = VALIDATION_DATA if not os.path.exists(dataDir): print( 'Please specify a valid data directory, "%s" is not a valid directory. Exiting...' % dataDir) return else: print('Using dataset %s' % dataDir) print("Using checkpoint directory: {0}".format(ckptDir)) is_training = (runMode == 'train') batch_size = 1 if runMode == 'sample' else BATCH_SIZE numEpochs = numEpochs if is_training else 1 overrideCkpt = overrideCkpt if is_training else False printSeparator('Initializing %s/reading constants.py' % modelStr) input_sz = [IMG_DIM, IMG_DIM, 1] if modelStr == 'unet': output_sz = [IMG_DIM, IMG_DIM, 3] curModel = Unet(input_sz, output_sz) if modelStr == 'zhangnet': output_sz = [(IMG_DIM / 4)**2, 512] curModel = ZhangNet(input_sz, output_sz) printSeparator('Building ' + modelStr) curModel.create_model() curModel.metrics() print("Running {0} model for {1} epochs.".format(modelStr, numEpochs)) print("Reading in {0}-set filenames.".format(runMode)) global_step = tf.Variable( 0, trainable=False, name='global_step') #tf.contrib.framework.get_or_create_global_step() saver = tf.train.Saver(max_to_keep=numEpochs) step = 0 counter = 0 if runMode == 'sample': logDir, logName = None, None else: logDir, logName = createLog(runMode) # get the data file names and check if the @dataDir is a hdf5 file if is_training: dataset_filenames = getDataFileNames( dataDir, excludeFnames=['.filepart', 'test']) else: dataset_filenames = getDataFileNames(dataDir, excludeFnames=['.filepart']) if ('.jpg' in dataset_filenames[0]) or ('.png' in dataset_filenames[0]): print('The input data is detected to be raw images') NUM_SAMPLES = len(dataset_filenames) dataset_filenames = [dataset_filenames] printSeparator('Starting TF session') with tf.Session(config=GPU_CONFIG) as sess: print("Inititialized TF Session!") # load checkpoint if necessary i_stopped, found_ckpt = get_checkpoint(overrideCkpt, ckptDir, sess, saver) # save weights # printVars() # show_weights(getVar(sess, 'combine_3/kernel:0')) # exit(0) if runMode != 'sample': file_writer = tf.summary.FileWriter(logDir, graph=sess.graph, max_queue=10, flush_secs=30) if (not found_ckpt): if is_training: init_op = tf.global_variables_initializer( ) # tf.group(tf.initialize_all_variables(), tf.initialize_local_variables()) init_op.run() else: # Exit if no checkpoint to test] print('Valid checkpoint not found under %s, exiting...' % ckptDir) return if not is_training: numEpochs = i_stopped + 1 # run the network for epochCounter in range(i_stopped, numEpochs): batch_loss = [] printSeparator("Running epoch %d" % epochCounter) random.shuffle(dataset_filenames) for j, data_file in enumerate(dataset_filenames): mini_loss = [] for iter_val in range(DATA_LOAD_PARTITION): # Get data print('Reading data in %s, iter_val: %d...' % (data_file, iter_val)) # try: if runMode == 'sample' and PAPER_IMG_NAMES != None: input_batches, output_batches, imgNames = h52numpy( data_file, batch_sz=batch_size, iter_val=iter_val, mod_output=(modelStr == 'zhangnet'), fileNames=PAPER_IMG_NAMES) print(input_batches.shape) else: input_batches, output_batches, imgNames = h52numpy( data_file, batch_sz=batch_size, iter_val=iter_val, mod_output=(modelStr == 'zhangnet')) # except: # logToFile(logName, "File reading failed...") # continue print('Done reading, running the network (%d of %d)' % (j + 1, len(dataset_filenames))) bar = progressbar.ProgressBar( maxval=int(len(input_batches) / batch_size)) bar.start() count = 0 for dataIndx in range(0, len(imgNames), batch_size): in_batch = input_batches[dataIndx:dataIndx + batch_size] if output_batches is None: out_batch = None else: out_batch = output_batches[dataIndx:dataIndx + batch_size] imgName = imgNames[dataIndx:dataIndx + batch_size] # look at the images in the dataset (for debug usage) #for kk in range(batch_size): # numpy2jpg('tmp'+str(kk+dataIndx)+'.jpg', in_batch[kk,:,:,0], overlay=None, meanVal=LINE_MEAN, verbose=False) # numpy2jpg('KAK'+str(kk+dataIndx)+'.jpg', out_batch[kk,:,:], overlay=None, meanVal=1, verbose=False) #if dataIndx>batch_size*2: # exit(0) if runMode == 'sample': curModel.sample( sess, in_batch, out_batch, imgName=[os.path.join(sampleDir, imgName[0])]) if (NUM_SAMPLES - 1) == step: exit(0) else: summary_loss, loss = curModel.run( sess, in_batch, out_batch, is_training, imgName=os.path.join(sampleDir, imgName[0])) file_writer.add_summary(summary_loss, step) batch_loss.append(loss) mini_loss.append(loss) # Processed another batch step += 1 count += 1 bar.update(count) bar.finish() input_batches = None output_batches = None logToFile( logName, "Epoch %d Dataset #%d loss: %f" % (epochCounter, j, np.mean(mini_loss))) counter += 1 # run the sample images through the net to record the results to the Tensorflow (also locally stored) if is_training: img_summary = curModel.sample(sess, out2board=True, imgName=logDir + '/imgs') file_writer.add_summary(img_summary, counter) if counter % SAVE_CKPT_COUNTER == 0: save_checkpoint( ckptDir, sess, saver, i_stopped + int(counter / SAVE_CKPT_COUNTER)) test_loss = np.mean(batch_loss) logToFile(logName, "Epoch %d loss: %f" % (epochCounter, test_loss)) if is_training: # Checkpoint model - every epoch #save_checkpoint(ckptDir, sess, saver, epochCounter) pass elif runMode != 'sample': if runMode == 'val': # Update the file for choosing best hyperparameters curFile = open(curModel.config.val_filename, 'a') curFile.write("Validation set loss: {0}".format(test_loss)) curFile.write('\n') curFile.close()
} # y_ints = [y] # class_weights = class_weight.compute_class_weight('balanced', 8, y_ints) # class_weights = dict(enumerate(class_weights)) os.environ["CUDA_VISIBLE_DEVICES"] = "0, 1" tfconfig = tf.ConfigProto() tfconfig.gpu_options.allow_growth = True tfconfig.allow_soft_placement = True sess = tf.Session(config=tfconfig) sess.run(tf.compat.v1.global_variables_initializer()) keras.backend.set_session(sess) input_img = Input((512, 512, 3)) model = Unet(input_img, 16, 0.1, True) learning_rate = 0.001 epochs = 500 decay_rate = learning_rate / epochs model.compile(optimizer=Adam(lr=learning_rate, decay=decay_rate), loss='mse') model.summary() history = model.fit(x=x, y=x, batch_size=32, epochs=20) maxpool_model = keras.Sequential() maxpool_model.add(layers.MaxPooling2D(pool_size=(2, 2), strides=2)) flair_encoder = Model(model.input, model.get_layer('activation_10').output) flair_encoder.summary() bottleneck = flair_encoder.predict(x)
def _build_test(self): output = Unet(name="UNet", in_data=self.input_data, reuse=False) self.Saver = tf.train.Saver(max_to_keep=10, name=self.saver_name) return output
train_loader = DataLoader(train_data , batch_size = 4,shuffle=True) valid_data = Ultrasound_Dataset(valid_df,transform=transforms_valid) valid_loader = DataLoader(valid_data , batch_size = 4,shuffle=False) # Checking GPU Avalaibility use_cuda = True if use_cuda and torch.cuda.is_available(): print('yes') print(torch.cuda.is_available()) # Model Initialization model = Unet(1,net_type='semi_inception',version='b',add_residual=True) if use_cuda and torch.cuda.is_available(): model.cuda() criterion = CustomLoss(0.5,1) optimizer = optim.Adam(model.parameters(),5e-6) scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, 'min', patience = 3) training_loss,valid_loss,model,saved_model=train_(model,optimizer,scheduler,criterion,train_loader,valid_loader,epochs=5) plot_learning_curve(training_loss,valid_loss) # save model for further use torch.save(model.state_dict(),'../Mymodel')
# In[6]: plt.imshow(isbi.train[0].reshape(512, 512), cmap='gray'); # In[7]: plt.imshow(isbi.targets[0].reshape(512, 512) , cmap='gray'); # In[8]: unet = Unet() unet.cuda(); # In[9]: trainer = Trainer(unet) # In[10]: criterion = nn.BCEWithLogitsLoss()
def train(args): # device device = torch.device("cuda:%d" % args.gpu if torch.cuda.is_available() else "cpu") # data trainset = SonyDataset(args.input_dir, args.gt_dir, args.ps) train_loader = DataLoader(trainset, batch_size=args.batch_size, shuffle=True, num_workers=12, pin_memory=True) logging.info("data loading okay") # model model = Unet().to(device) # loss function criterion = nn.L1Loss() # optimizer optimizer = optim.Adam(model.parameters(), lr=args.lr, weight_decay=args.wd) # lr scheduler scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=2000, gamma=0.1) # training running_loss = 0.0 for epoch in range(args.num_epoch): scheduler.step() for i, databatch in enumerate(train_loader): # get the inputs input_patch, gt_patch, train_id, ratio = databatch input_patch, gt_patch = input_patch.to(device), gt_patch.to(device) # zero the parameter gradients optimizer.zero_grad() # forward + backward + optimize outputs = model(input_patch) loss = criterion(outputs, gt_patch) loss.backward() optimizer.step() # print statistics running_loss += loss.item() if i % args.log_interval == (args.log_interval - 1): print('[%d, %5d] loss: %.3f %s' % (epoch, i, running_loss / args.log_interval, datetime.now())) running_loss = 0.0 if epoch % args.save_freq == 0: if not os.path.isdir( os.path.join(args.result_dir, '%04d' % epoch)): os.makedirs(os.path.join(args.result_dir, '%04d' % epoch)) gt_patch = gt_patch.cpu().detach().numpy() outputs = outputs.cpu().detach().numpy() train_id = train_id.numpy() ratio = ratio.numpy() temp = np.concatenate( (gt_patch[0, :, :, :], outputs[0, :, :, :]), axis=2) scipy.misc.toimage( temp * 255, high=255, low=0, cmin=0, cmax=255).save(args.result_dir + '%04d/%05d_00_train_%d.jpg' % (epoch, train_id[0], ratio[0])) # at the end of epoch if epoch % args.model_save_freq == 0: torch.save(model.state_dict(), args.checkpoint_dir + './model_%d.pl' % epoch)
X_train_t1 = np.zeros((285, 240, 240, 155)) X_train_t1ce = np.zeros((285, 240, 240, 155)) X_train_flair = np.zeros((285, 240, 240, 155)) X_train_t2 = np.zeros((285, 240, 240, 155)) t1_small_ = np.zeros((285, 144, 144, 155)) t1ce_small_ = np.zeros((285, 144, 144, 155)) flair_small_ = np.zeros((285, 144, 144, 155)) t2_small_ = np.zeros((285, 144, 144, 155)) t1_small = np.zeros((285, 144, 144, 100)) t1ce_small = np.zeros((285, 144, 144, 100)) flair_small = np.zeros((285, 144, 144, 100)) t2_small = np.zeros((285, 144, 144, 100)) input_img = Input((144, 144, 100)) model = Unet(input_img, 16, 0.1, True) learning_rate = 0.001 epochs = 500 decay_rate = learning_rate / epochs model.compile(optimizer=Adam(lr=learning_rate, decay=decay_rate), loss='mse') model.summary() # data preprocessing starts here path = 'BRATS2017/Brats17TrainingData/HGG' all_images = os.listdir(path) # print(len(all_images)) all_images.sort() data = np.zeros((240, 240, 155, 4)) for i in range(len(all_images)):