def get_model(self) -> Model: """Get selected model. Returns ------- Model Keras model object, compiled. """ # Build the model optimizer = RMSprop(self.learning_rate) if self.model_type == "unet": model = models.unet(self.input_shape, self.classes, optimizer, self.loss) elif self.model_type == "unet_large": model = models.unet_large(self.input_shape, self.classes, optimizer, self.loss) elif self.model_type == "fcdensenet": model = models.fcdensenet(self.input_shape, self.classes, optimizer, self.loss) elif self.model_type == "fcn_small": model = models.fcn_small(self.input_shape, self.classes, optimizer, self.loss) model.summary() return model
def get_model(self) -> Model: """Get selected model. Returns ------- Model Keras model object, compiled. """ # Build the model optimizer = RMSprop(self.learning_rate) if self.model_type == "unet": model = models.unet(self.input_shape, self.classes, optimizer, self.loss) elif self.model_type == "unet_large": model = models.unet_large(self.input_shape, self.classes, optimizer, self.loss) elif self.model_type == "fcdensenet": model = models.fcdensenet(self.input_shape, self.classes, optimizer, self.loss) elif self.model_type == "fcn_small": model = models.fcn_small(self.input_shape, self.classes, optimizer, self.loss) if self.preload_weights: logger.info( "=====================================================") logger.info(f"Using weights from {self.preload_weights}") logger.info( "=====================================================") model.load_weights(self.preload_weights) model.run_eagerly = True model.summary() return model
def train_unet(input_shape, final_channels): _model = unet(input_shape, final_channels, use_pooling=False, skip_layers='inception', final_activation='sigmoid') _model.load_weights('degan/generator.h5') lr = 2e-3 _model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=lr), loss='mse', metrics='mae') tensorboard = TensorBoard(profile_batch='10, 20') model_path = 'unet/unet.h5' model_checkpoints = ModelCheckpoint(model_path, monitor='mae', save_best_only=True, verbose=1) lr_sch = ReduceLROnPlateau(monitor='mae', factor=0.5, verbose=1) callbacks = [lr_sch, tensorboard, model_checkpoints] return _model, callbacks
def iterate_over_image_and_evaluate_patchwise_cnn(image_stack, model_path, out_filename, out_meta, n_classes, tile_size=24): model = unet((None, None, 98), n_classes=3, initial_exp=5) model.load_weights(model_path) print(image_stack.shape) image_stack = np.swapaxes(image_stack, 0, 2) image_stack = np.expand_dims(image_stack, 0) print(image_stack.shape) predictions = np.zeros( (image_stack.shape[1], image_stack.shape[2], n_classes)) for i in range(0, image_stack.shape[1] - tile_size, tile_size): for j in range(0, image_stack.shape[2] - tile_size, tile_size): image_tile = image_stack[:, i:i + tile_size, j:j + tile_size, :] if np.all(image_tile == 0): continue predictions[i:i + tile_size, j:j + tile_size, :] = np.squeeze( model.predict(image_tile)) stdout.write("{:.3f}\r".format(i / image_stack.shape[1])) predictions = np.swapaxes(predictions, 0, 2) out_meta.update({'count': n_classes, 'dtype': np.float64}) with rasopen(out_filename, "w", **out_meta) as dst: dst.write(predictions)
def main(args): optimizer = Adam(args.learning_rate) mdl = models.unet() class_weight = 1. * (constants.class_radius[args.label]** 2) / (args.crop_size**2) / 2 mdl.compile(optimizer, lambda x, y: weighted_logloss(x, y, class_weight)) # mdl.compile(optimizer, jaccard) train_generator = RandomRastorGenerator(args.train_dir, label=args.label, label_file=args.label_file, batch_size=args.batch_size, crop_size=args.crop_size, transformer=transformer) val_generator = RandomRastorGenerator(args.val_dir, label=args.label, label_file=args.label_file, batch_size=args.batch_size, crop_size=args.crop_size, transformer=transformer) # print 'train_gen size: {}, val_gen size: {}'.format(len(train_generator), len(val_generator)) sess = K.get_session() writer = tf.summary.FileWriter(os.path.join(args.model_dir, 'logs'), sess.graph) best_loss = None step = 0 stop_count = 0 for epoch in xrange(args.num_epochs): # train batch_x, batch_y = train_generator.next() loss = mdl.train_on_batch(batch_x, batch_y) if step % 25 == 0: print 'Step {}: Loss = {}'.format(step, loss) # write train/val loss summary if step % STEPS_PER_VAL == 0: train_loss, train_summary = get_summary('train_loss', mdl, train_generator) val_loss, val_summary = get_summary('val_loss', mdl, val_generator) writer.add_summary(train_summary, epoch) writer.add_summary(val_summary, epoch) print 'Train_loss: {}, Val_loss: {}'.format(train_loss, val_loss) if (best_loss is None) or (val_loss < best_loss): print 'New best validation loss. Saving...' best_loss = val_loss stop_count = 0 mdl.save(os.path.join(args.model_dir, 'weights.h5')) else: stop_count += 1 if args.early_stop > 0 and stop_count >= args.early_stop: print 'Validation loss did not improve after {} steps. Stopping...'.format( args.early_stop) break step += 1
def get_model(self) -> Model: """Get selected model. Returns ------- Model Keras model object, compiled. """ # Build the model optimizer = RMSprop(self.learning_rate) if self.model_type == "unet": model = models.unet( self.input_shape, self.classes, self.loss, ) elif self.model_type == "unet_large": model = models.unet_large( self.input_shape, self.classes, self.loss, ) elif self.model_type == "fcdensenet": model = models.fcdensenet( self.input_shape, self.classes, self.loss, ) elif self.model_type == "fcn_small": model = models.fcn_small(self.input_shape, self.classes, self.loss) if self.preload_weights: logger.info( "=====================================================") logger.info(f"Using weights from {self.preload_weights}") logger.info( "=====================================================") model.load_weights(self.preload_weights) if config.FINE_TUNE_AT > 0: for layer in model.layers[:config.FINE_TUNE_AT]: layer.trainable = False logger.info( "=====================================================") logger.info(f"Fine tuning from %d layer" % config.FINE_TUNE_AT) logger.info( "=====================================================") model = models.compile_model(model, self.loss, optimizer) model.run_eagerly = True model.summary() return model
def model_load(model_path): model_path = model_path # We need to create an SSDLoss object in order to pass that to the model # loader. ssd_loss = SSDLoss(neg_pos_ratio=3, alpha=0.8) K.clear_session() # Clear previous models from memory. model = load_model(os.path.join(model_path, 'ssd300_all.h5'), custom_objects={'AnchorBoxes': AnchorBoxes, 'L2Normalization': L2Normalization, 'compute_loss': ssd_loss.compute_loss}) model2 = unet() model2.load_weights(os.path.join(model_path, "unet_8.hdf5")) return model, model2
def train_wgan(input_shape, final_channels): generator = unet(input_shape, final_channels, use_pooling=False, skip_layers='inception', final_activation='tanh') disc_model = discriminator(INPUT_SHAPE, final_activation='linear') # generator.load_weights('degan/generator.h5') # discriminator.load_weights('degan/discriminator.h5') _model = DEGAN(generator, disc_model) gen_decay_rate = 5e-4 disc_decay_rate = 1e-4 _model.compile(tf.keras.optimizers.Adam(learning_rate=gen_decay_rate), tf.keras.optimizers.RMSprop(learning_rate=disc_decay_rate), wasserstein_gen_loss_fn, wasserstein_disc_loss_fn) gen_lr = CustomReduceLROnPlateau(_model.gen_optimizer, 'gen_lr', monitor='generator_loss', patience=200, factor=RATE_DECAY, verbose=1) disc_lr = CustomReduceLROnPlateau(_model.disc_optimizer, 'disc_lr', monitor='discriminator_loss', patience=200, factor=RATE_DECAY, verbose=1) model_path = 'degan/model_name.h5' model_checkpoints = ModelCheckpoint(model_path, monitor='generator_mae', save_best_only=True, verbose=1) tensorboard = TensorBoard(profile_batch='10, 20') callbacks = [gen_lr, disc_lr, tensorboard, model_checkpoints] return _model, callbacks
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 train(df, gs, batch_size=128, epochs=1000, validation_size=1000, test_size=1000): train_img_ids = get_training_img_ids(df) (x_train_list, y_train_list) = get_train_data(train_img_ids, df, gs) model = unet((INPUT_SIZE, INPUT_SIZE, x_train_list[0].shape[2]), len(CLASSES)) model.compile(optimizer=Adam(), loss=binary_crossentropy, metrics=[jaccard_index]) (x_val_patches, y_val_patches) = get_patches(x_train_list, y_train_list, validation_size) for epoch in range(epochs): (x_train_patches, y_train_patches) = get_patches(x_train_list, y_train_list, batch_size) train_scores = model.train_on_batch(x_train_patches, y_train_patches) val_scores = eval_model(model, x_val_patches, y_val_patches, batch_size) print('[Epoch {}] Loss: {} - Accuracy: {} - Validation Accuracy: {}'. format(epoch, train_scores[0], train_scores[1], val_scores[1])) (x_test_patches, y_test_patches) = get_patches(x_train_list, y_train_list, test_size) test_scores = eval_model(model, x_test_patches, y_test_patches, batch_size) print('Test Accuracy: {}'.format(test_scores[1])) save_model(model)
gpus = tf.config.experimental.list_physical_devices('GPU') # Currently, memory growth needs to be the same across GPUs for gpu in gpus: tf.config.experimental.set_memory_growth(gpu, True) # path to zipped & working directories path_zip = r'E:\Data\denoising-dirty-documents' wd = os.path.join(path_zip, 'working') test_img = sorted(glob(os.path.join(wd, 'test', '*.png'))) INPUT_SHAPE = (256, 256, 1) model = unet(INPUT_SHAPE, 1, use_pooling=False, skip_layers='inception', final_activation='sigmoid') model.load_weights('unet/unet.h5') def crop_img(img, crop_shape): img_shape = img.shape imgs = [] points = [] for y in range(0, img_shape[0], crop_shape[0]): for x in range(0, img_shape[1], crop_shape[1]): if y + crop_shape[0] >= img_shape[0]: y = img_shape[0] - crop_shape[0] - 1 if x + crop_shape[1] >= img_shape[1]: x = img_shape[1] - crop_shape[1] - 1 _crop_img = img[y: y + crop_shape[1], x: x + crop_shape[0]]
valid_test_ds, (args.valid_set, args.test_set)) valid_dl = DataLoader(valid_ds, batch_size=10, shuffle=True) test_dl = DataLoader(test_ds, batch_size=10, shuffle=False) # Define the RGB Seg Network network device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') if args.ML_network == 'DENSE-UNet': from models import UNet model = UNet() elif args.ML_network == 'ResNet-UNet': from models import ResNetUNet model = ResNetUNet(3) elif args.ML_network == 'U-Net': from models import unet model = unet() model = model.to(device) # Set A function for training def train_model(model, optimizer, num_epochs=25): best_model_wts = copy.deepcopy(model.state_dict()) best_loss = 1e10 train_loss, valid_loss = [], [] for epoch in range(num_epochs): print('Epoch {}/{}'.format(epoch, num_epochs - 1)) print('-' * 10)
from config import model_name, n_classes from models import unet, fcn_8 def sorted_fns(dir): return sorted(os.listdir(dir), key=lambda x: int(x.split('.')[0])) if len(os.listdir('images')) != len(os.listdir('annotated')): generate_missing_json() image_paths = [os.path.join('images', x) for x in sorted_fns('images')] annot_paths = [os.path.join('annotated', x) for x in sorted_fns('annotated')] if 'unet' in model_name: model = unet(pretrained=False, base=4) elif 'fcn_8' in model_name: model = fcn_8(pretrained=False, base=4) tg = DataGenerator(image_paths=image_paths, annot_paths=annot_paths, batch_size=3, augment=True) checkpoint = ModelCheckpoint(os.path.join('models', model_name + '.model'), monitor='dice', verbose=1, mode='max', save_best_only=True, save_weights_only=False, period=10)
def main(): prog_name = sys.argv[0] args = do_args(sys.argv[1:], prog_name) verbose = args.verbose output = args.output name = args.name data_dir = args.data_dir training_states = args.training_states validation_states = args.validation_states superres_states = args.superres_states num_epochs = args.epochs model_type = args.model_type batch_size = args.batch_size learning_rate = args.learning_rate time_budget = args.time_budget loss = args.loss do_color_aug = args.color do_superres = loss == "superres" log_dir = os.path.join(output, name) assert os.path.exists(log_dir), "Output directory doesn't exist" f = open(os.path.join(log_dir, "args.txt"), "w") for k, v in args.__dict__.items(): f.write("%s,%s\n" % (str(k), str(v))) f.close() print("Starting %s at %s" % (prog_name, str(datetime.datetime.now()))) start_time = float(time.time()) #------------------------------ # Step 1, load data #------------------------------ training_patches = [] for state in training_states: print("Adding training patches from %s" % (state)) fn = os.path.join(data_dir, "%s_extended-train_patches.csv" % (state)) df = pd.read_csv(fn) for fn in df["patch_fn"].values: training_patches.append((os.path.join(data_dir, fn), state)) validation_patches = [] for state in validation_states: print("Adding validation patches from %s" % (state)) fn = os.path.join(data_dir, "%s_extended-val_patches.csv" % (state)) df = pd.read_csv(fn) for fn in df["patch_fn"].values: validation_patches.append((os.path.join(data_dir, fn), state)) print("Loaded %d training patches and %d validation patches" % (len(training_patches), len(validation_patches))) if do_superres: print("Using %d states in superres loss:" % (len(superres_states))) print(superres_states) #------------------------------ # Step 2, run experiment #------------------------------ #training_steps_per_epoch = len(training_patches) // batch_size #validation_steps_per_epoch = len(validation_patches) // batch_size training_steps_per_epoch = 300 validation_steps_per_epoch = 39 print("Number of training/validation steps per epoch: %d/%d" % (training_steps_per_epoch, validation_steps_per_epoch)) # Build the model optimizer = RMSprop(learning_rate) if model_type == "unet": model = models.unet((240, 240, 4), 5, optimizer, loss) elif model_type == "unet_large": model = models.unet_large((240, 240, 4), 5, optimizer, loss) elif model_type == "fcdensenet": model = models.fcdensenet((240, 240, 4), 5, optimizer, loss) elif model_type == "fcn_small": model = models.fcn_small((240, 240, 4), 5, optimizer, loss) model.summary() validation_callback = utils.LandcoverResults(log_dir=log_dir, time_budget=time_budget, verbose=verbose) learning_rate_callback = LearningRateScheduler(utils.schedule_stepped, verbose=verbose) model_checkpoint_callback = ModelCheckpoint(os.path.join( log_dir, "model_{epoch:02d}.h5"), verbose=verbose, save_best_only=False, save_weights_only=False, period=20) training_generator = datagen.DataGenerator( training_patches, batch_size, training_steps_per_epoch, 240, 240, 4, do_color_aug=do_color_aug, do_superres=do_superres, superres_only_states=superres_states) validation_generator = datagen.DataGenerator(validation_patches, batch_size, validation_steps_per_epoch, 240, 240, 4, do_color_aug=do_color_aug, do_superres=do_superres, superres_only_states=[]) model.fit_generator( training_generator, steps_per_epoch=training_steps_per_epoch, #epochs=10**6, epochs=num_epochs, verbose=verbose, validation_data=validation_generator, validation_steps=validation_steps_per_epoch, max_queue_size=256, workers=4, use_multiprocessing=True, callbacks=[ validation_callback, #learning_rate_callback, model_checkpoint_callback ], initial_epoch=0) #------------------------------ # Step 3, save models #------------------------------ model.save(os.path.join(log_dir, "final_model.h5")) model_json = model.to_json() with open(os.path.join(log_dir, "final_model.json"), "w") as json_file: json_file.write(model_json) model.save_weights(os.path.join(log_dir, "final_model_weights.h5")) print("Finished in %0.4f seconds" % (time.time() - start_time)) del model, training_generator, validation_generator
with tf.Graph().as_default(), tf.Session() as sess: # placeholders for training data phone_ = tf.placeholder(tf.float32, [None, PATCH_SIZE]) phone_image = tf.reshape(phone_, [-1, PATCH_HEIGHT, PATCH_WIDTH, 3]) dslr_ = tf.placeholder(tf.float32, [None, PATCH_SIZE]) dslr_image = tf.reshape(dslr_, [-1, PATCH_HEIGHT, PATCH_WIDTH, 3]) adv_ = tf.placeholder(tf.float32, [None, 1]) # get processed enhanced image enhanced = models.unet(phone_image) # transform both dslr and enhanced images to grayscale enhanced_gray = tf.reshape(tf.image.rgb_to_grayscale(enhanced), [-1, PATCH_WIDTH * PATCH_HEIGHT]) dslr_gray = tf.reshape(tf.image.rgb_to_grayscale(dslr_image), [-1, PATCH_WIDTH * PATCH_HEIGHT]) # push randomly the enhanced or dslr image to an adversarial CNN-discriminator adversarial_ = tf.multiply(enhanced_gray, 1 - adv_) + tf.multiply( dslr_gray, adv_) adversarial_image = tf.reshape(adversarial_, [-1, PATCH_HEIGHT, PATCH_WIDTH, 1])
import models from data import gen, test_data from keras.callbacks import ModelCheckpoint, EarlyStopping shape = (128, 128) batch_size = 1 # Load model print('\n') print('-' * 30) print('Loading model...') print('-' * 30) model = models.unet(shape, models.res_block_basic, models.Activation('relu'), 0, False) #model = models.get_unet(shape) #model = models.test_net(shape) callbacks = [ EarlyStopping(monitor='val_loss', patience=3, verbose=0), ModelCheckpoint('./weights/weights.hdf5', monitor='val_loss', save_best_only=True) ] # Training print('\n') print('-' * 30) print('Begin training...') print('-' * 30) dgen = gen(shape, batch_size) model.fit_generator(generator=dgen, samples_per_epoch=batch_size * 50,
# defining set of callbacks callbacks_list = [checkpoint, csv_logger, earlystopping] results = train_model.fit_generator(train_gen, epochs=epochs, steps_per_epoch=100, validation_data=val_gen, validation_steps=20, callbacks=callbacks_list) return results if __name__ == '__main__': dataset_object = CelebADataset() train_gen, val_gen = dataset_object.data_gen(Constant.TRAIN_FRAMES_DIR, Constant.TRAIN_MASKS_DIR, Constant.VAL_FRAMES_DIR, Constant.VAL_MASKS_DIR) # define model weights_path = 'best_model.h5' model = models.unet(pretrained_weights=weights_path) results = Runner().train(model, weights_path=weights_path, epochs=15, batch_size=Constant.BATCH_SIZE) print(results)
def main(): args = parse_args() timestr = time.strftime("%Y%m%d%H%M%S") log_dir_parent = args.log_directory log_dir = log_dir_parent + "/{}".format(timestr) checkpoints_dir = log_dir + "/checkpoints" os.mkdir(log_dir) os.mkdir(checkpoints_dir) optimizer = Adam() train = np.load(args.data_directory + "/train.npy") valid = np.load(args.data_directory + "/valid.npy") callbacks = [ Logger( filename=log_dir + "/{}.log".format(timestr), optimizer=optimizer, sigma=args.sigma, epochs=args.epochs, batch_size=args.batch_size, dataset_dir=args.data_directory, checkpoints_dir=checkpoints_dir, noise2noise=args.noise2noise, dtype=train.dtype), CSVLogger(log_dir + "/{}.csv".format(timestr)), TerminateOnNaN(), ModelCheckpoint( checkpoints_dir + '/checkpoint.' + timestr + \ '.{epoch:03d}-{val_loss:.3f}-{val_psnr:.5f}.h5', monitor='val_psnr', mode='max', save_best_only=True) ] # Build PSNR function if train.dtype == np.uint8: psnr = get_psnr(8) elif train.dtype == np.uint16: psnr = get_psnr(16) elif np.issubdtype(train.dtype, np.floating): psnr = get_psnr(1) else: raise TypeError model = unet(shape=(None, None, 1)) model.compile(optimizer=optimizer, loss='mse', metrics=[psnr]) # Same noise for all training procedure # train_input = NoiseGenerator.add_gaussian_noise(train, args.sigma) # if args.noise2noise: # train_target = NoiseGenerator.add_gaussian_noise(train, args.sigma) # else: # train_target = train # valid_input = NoiseGenerator.add_gaussian_noise(valid, args.sigma) # valid_target = valid # Validation images should be clean # hist = model.fit(train_input, train_target, # epochs=args.epochs, # batch_size=args.batch_size, # verbose=args.verbose, # callbacks=callbacks, # validation_data=(valid_input, valid_target)) # New noise for each new batch train_generator = NoiseGenerator(data=train, batch_size=args.batch_size, sigma=args.sigma, noise2noise=args.noise2noise) valid_generator = NoiseGenerator(data=valid, batch_size=args.batch_size, sigma=args.sigma, noise2noise=False) model.fit_generator(generator=train_generator, epochs=args.epochs, verbose=args.verbose, callbacks=callbacks, validation_data=valid_generator)
def main(epochs=100, batch_size=32): train_df = pd.read_csv(TRAIN_DF_PATH) imgs = [] masks = [] coverage_classes = [] print('Loading training data') for img_id in tqdm(train_df.id): img_path = os.path.join(TRAIN_IMGS_DIR, '{}.png'.format(img_id)) img = np.array(load_img(img_path, color_mode='grayscale')) / 255 imgs.append(img) mask_path = os.path.join(TRAIN_MASKS_DIR, '{}.png'.format(img_id)) mask = np.array(load_img(mask_path, color_mode='grayscale')) / 255 masks.append(mask) coverage = np.sum(mask) / (IMG_SIZE * IMG_SIZE) coverage_class = coverage_to_class(coverage) coverage_classes.append(coverage_class) print('Training data loaded') x_train, x_val, y_train, y_val = train_test_split( np.array(list(map(upsample, imgs))).reshape(-1, IMG_MODEL_SIZE, IMG_MODEL_SIZE, 1), np.array(list(map(upsample, masks))).reshape(-1, IMG_MODEL_SIZE, IMG_MODEL_SIZE, 1), test_size=0.2, stratify=coverage_classes, ) x_train, y_train = data_augmentation(x_train, y_train) x_train = np.repeat(x_train, 3, axis=3) x_val = np.repeat(x_val, 3, axis=3) model = unet((IMG_MODEL_SIZE, IMG_MODEL_SIZE, 3)) model.compile(loss='binary_crossentropy', optimizer='adam', metrics=[iou_metric]) result_dir = os.path.join(RESULTS_DIR, str(time.time())) if not os.path.exists(result_dir): os.makedirs(result_dir) model_output_path = os.path.join(result_dir, 'unet_resnet50.model') raw_output_path = os.path.join(result_dir, 'history.pickle') plot_output_path = os.path.join(result_dir, 'plot.png') model_checkpoint = ModelCheckpoint(model_output_path, monitor='val_iou_metric', mode='max', save_best_only=True, verbose=1) history = model.fit(x_train, y_train, validation_data=[x_val, y_val], epochs=epochs, batch_size=batch_size, callbacks=[model_checkpoint], shuffle=True, verbose=1) save_history_raw(history, raw_output_path) save_history_plot(history, plot_output_path)
experiment_name = 'experiment name' #set experiment name save_folder = os.path.join('results', d, experiment_name) if not os.path.exists(save_folder): os.makedirs(save_folder) #deifne call backs checkpointer = ModelCheckpoint(os.path.join(save_folder, 'best_model.h5'), monitor='val_loss', verbose=1, save_best_only=True) csv_logger = CSVLogger(os.path.join(save_folder, 'log.csv'), append=True, separator=';') early_stopper = EarlyStopping(monitor='val_loss', patience=10) callbacks_list = [checkpointer, csv_logger, early_stopper] #build model and compile model = unet(input_shape=(ih, iw, 3)) model.compile(loss=loss, optimizer=opt) history = model.fit(train_gen, epochs=n_epochs, steps_per_epoch=(tstop // batch_size), validation_data=val_gen, validation_steps=((vstop - vstart) // batch_size), callbacks=callbacks_list, verbose=1)
#Try more or less layers #Try w and w/o Batchnormalization() #-Fit----------------------------------------------------------------------- epochs = 100 batch_size = 1 callbacks=[EarlyStopping(patience=16,verbose=1),\ ReduceLROnPlateau(factor=0.1, patience=5, min_delta=0.001, min_lr=0.0000001,verbose=1),\ ModelCheckpoint('modelName.h5'.format(epochs),verbose=1, save_best_only=True,\ save_weights_only=False),\ CSVLogger('modelName.log')] #DON'T OVERWRITE #module 'h5py' has no attribute 'Group' <-- if folder does not exist #----------------------------------------------------------------------------- model = unet(pretrained_weights = pretrained_weights, input_size = input_size, weights = weights,\ activation=activation, dropout=dropout, loss=loss, optimizer=optimizer, dilation_rate=dilation_rate) #for array dataset with shape (n_img, size, size) one more dimension needs to be created in order to train images_all = images_original[..., np.newaxis] test_images_all = test_images_original[..., np.newaxis] #normalize (not very effective if e.g. in one image maximum is 35000 and in another 15000. Background (and everything else) will be different) # normalization_value = 255 # images_all = images_all/images_all.max()*normalization_value # test_images_all = test_images_all/test_images_original.max()*normalization_value results = model.fit(images_all, masks, validation_split=split, epochs=epochs, batch_size=batch_size,\ callbacks=callbacks, shuffle=True) print('Model correctly trained and saved') plt.figure(figsize=(8, 8)) plt.grid(False)
im_size = (512, 512, 1) n_classes = 3 dataset_name = os.path.join('.', 'data', 'liver_dataset.npz') # preprocess data if necessary if not os.path.isfile(dataset_name): data_preprocessing.preprocess_data_folder(os.path.join('.', 'data')) # load data dataset = np.load(dataset_name) x, y, xv, yv = dataset['x'], dataset['y'], dataset['xv'], dataset['yv'] m, s = dataset['m'], dataset['s'] model = unet(im_size=im_size, output_size=n_classes, n_blocks=6, n_convs=1, n_filters=8) # training parameters bs = 4 epochs = 6 # train model.m = m model.s = s history = model.fit(x, y, batch_size=bs, epochs=epochs, validation_data=(xv, yv),
epoch_size=cfg.epoch_size // cfg.batch_size, rotation=cfg.aug_rotation, scaling=cfg.aug_scaling) test_generator = DataGenerator(cfg.test_datasets, batch_size=cfg.batch_size, subframe_size=cfg.subframe_size, normalize_subframes=cfg.normalize_subframes, epoch_size=cfg.epoch_size // cfg.batch_size, rotation=cfg.aug_rotation, scaling=cfg.aug_scaling) # create model # model = models.unet(train_generator.shape_X[1:], train_generator.shape_y[-1], filters=cfg.filters) model = models.unet((None, None, train_generator.shape_X[-1]), train_generator.shape_y[-1], filters=cfg.filters, kernel_initializer='glorot_normal', batch_normalization=cfg.batch_normalization, high_pass_sigma=cfg.high_pass_sigma) # get predictions for single batch def save_prediction_imgs(generator, model_in, folder): X, y = generator[0] y_pred = model_in.predict(X) for i in range(X.shape[0]): file = os.path.join(folder, 'prediction%i.png' % i) utils.save_prediction_img(file, X[i], y[i], y_pred[i], X_contrast=(0, 100))
res_sizes = utils.get_resolutions() # get the specified image resolution IMAGE_HEIGHT, IMAGE_WIDTH, IMAGE_SIZE = utils.get_specified_res( res_sizes, phone, resolution) # disable gpu if specified config = tf.ConfigProto( device_count={'GPU': 0}) if use_gpu == "false" else None # create placeholders for input images x_ = tf.placeholder(tf.float32, [None, IMAGE_SIZE]) x_image = tf.reshape(x_, [-1, IMAGE_HEIGHT, IMAGE_WIDTH, 3]) # generate enhanced image enhanced = unet(x_image) with tf.Session(config=config) as sess: test_dir = dped_dir test_photos = [ f for f in os.listdir(test_dir) if os.path.isfile(test_dir + f) ] if test_subset == "small": # use five first images only test_photos = test_photos[0:5] if phone.endswith("_orig"): # load pre-trained model
img_train, img_val, mask_train, mask_val = train_test_split( images, masks, test_size=0.2, random_state=42) # hyperparameters batch_size = 8 seed = 1 lr = 0.0001 n_epochs = 100 size = (240, 240, 1) # call model, compile and fit Unet_Model = unet(Base=16, size=(240, 240, 1), batch_norm=True, dropout=True, drop_r=0.5, spatial_drop=False, spatial_drop_r=0.1, multi_class=False, classes=1) Unet_Model.compile(optimizer=Adam(lr=lr), loss=dice_coef_loss, metrics=[ dice_coef, tf.keras.metrics.Precision(), tf.keras.metrics.Recall() ]) History = Unet_Model.fit(img_train, mask_train, batch_size=batch_size, epochs=n_epochs,
for i in range(20000): np.random.shuffle(training_patches) np.random.shuffle(validation_patches) training_steps_per_epoch = 300 validation_steps_per_epoch = 25 print("Number of training/validation steps per epoch: %d/%d" % (training_steps_per_epoch, validation_steps_per_epoch)) # In[ ]: import models optimizer = RMSprop(learning_rate) model = models.unet((256, 256, 4), 8, optimizer, loss) #model.summary() # In[ ]: import datagen training_generator = datagen.DataGenerator(training_patches, batch_size, training_steps_per_epoch, 256, 256, 4) validation_generator = datagen.DataGenerator(validation_patches, batch_size, validation_steps_per_epoch, 256, 256, 4) # In[ ]: model_checkpoint_callback = ModelCheckpoint(os.path.join(
x_val = read.load_data_npy("/cmach-data/segthor/Val/") y_val = read.load_label_npy("/cmach-data/segthor/Val/") # x_test = read.load_test_data("/cmach-data/segthor/test/", 41, 60) print(len(x_train), len(x_val)) # preprocess input # x_train = preprocess_input(x_train) # x_val = preprocess_input(x_val) # define model # model = Unet(BACKBONE, input_shape=(None, None, 1), classes=5, encoder_weights=None) # model.compile('Adam', loss=bce_jaccard_loss, metrics=[iou_score]) # model = load_model('unet_membrane.hdf5') model = models.unet() model.compile('Adam', loss=bce_jaccard_loss, metrics=[iou_score]) model_checkpoint = ModelCheckpoint('ordjcd50.hdf5', monitor='loss', verbose=1, save_best_only=True) # fit model model.fit(x=x_train, y=y_train, batch_size=6, epochs=50, validation_data=(x_val, y_val), callbacks=[model_checkpoint])
import matplotlib.pyplot as plt import matplotlib.image as im import numpy as np # Deets and parameters nc_in = 1 nc_out = 1 ngf = 64 loadSize = 286 imageSize = 128 batchSize = 16 lrG = 2e-4 model = unet(imageSize, nc_in, nc_out, ngf) model.summary() # use (model.trainable = False) to freeze weights # test base unet without discriminator version first model.compile(loss='mean_squared_error', optimizer='adam', metrics=['accuracy']) #model.fit(self, x=None, y=None, batch_size=None, epochs=1, verbose=1, callbacks=None, validation_split=0.0, validation_data=None, shuffle=True, class_weight=None, sample_weight=None, initial_epoch=0, steps_per_epoch=None, validation_steps=None) # starts training img = im.imread('./datasets/facades/train/1.jpg') img = np.float32(img) img = np.array(img) / 255 * 2 - 1 plt.ion()
mask_subdirectory="label", batch_size=validation_batchsize, seed=seed ) print("\nTest dataset statistics:") test_generator = ImageDataGenerator(preprocessing_function=image_preprocessing).flow_from_directory( test_dir, target_size=(height, width), color_mode='rgb', classes=["."], class_mode=None, batch_size=test_batchsize, shuffle=False ) model = unet(**unet_args) if use_custom_losses is True: loss = image_categorical_crossentropy if background_as_class is True else image_binary_crossentropy else: loss = "categorical_crossentropy" if background_as_class is True else "binary_crossentropy" model.compile(optimizer=optimizer, loss=loss, metrics=["acc"]) model.summary() callbacks = [ callbacks.ModelCheckpoint(os.path.join(weights_dir, 'best_loss.hdf5'), monitor="loss", verbose=1, save_best_only=True, save_weights_only=False), callbacks.ModelCheckpoint(os.path.join(weights_dir, 'best_acc.hdf5'), monitor="acc", verbose=1, save_best_only=True, save_weights_only=False), callbacks.ModelCheckpoint(os.path.join(weights_dir, 'best_val_loss.hdf5'), monitor="val_loss", verbose=1, save_best_only=True, save_weights_only=False), callbacks.ModelCheckpoint(os.path.join(weights_dir, 'best_val_acc.hdf5'), monitor="val_acc",