def run(): parser = argparse.ArgumentParser() parser.add_argument("--weights-path", type=str) parser.add_argument("--input-images", type=str, default="") parser.add_argument("--output-path", type=str, default="") parser.add_argument("--input-size", type=int, default=713) parser.add_argument("--model-name", type=str, default="standard") parser.add_argument("--save-imgs", type=bool, default=True) args = parser.parse_args() model_name = args.model_name images_path = args.input_images input_size = args.input_size save_imgs = args.save_imgs model_choices = { 'densenet': build_densenet, 'unet': build_unet, 'unet-old': build_unet_old } model_choice = model_choices[model_name] model = model_choice((input_size, input_size), 1) gpus = get_number_of_gpus() if gpus > 1: model = ModelMGPU(model, gpus) model.compile(optimizer=Adam(lr=1e-4), loss=binary_soft_jaccard_loss, metrics=['acc', binary_jaccard_distance_rounded]) model.load_weights(args.weights_path) probs = [] for i, filename in enumerate(tqdm(os.listdir(images_path))): imgpath = os.path.join(images_path, filename) if not os.path.isfile(imgpath): continue img = np.array(Image.open(imgpath)) if not img.shape[0] == img.shape[1]: continue img = np.expand_dims(img, axis=0) prob = model.predict(img, verbose=1) probs.append(prob) probs = np.round(probs) if not save_imgs: return for i, prob in enumerate(probs): prob = (prob[:, :, 0] * 255.).astype(np.uint8) pred_name = "pred-{}.tif".format(i) pred_save_path = "{}/{}".format(args.output_path, pred_name) cv2.imwrite(pred_save_path, prob)
def lrtest_densenet(data_dir, logdir, weights_dir, weights_name, input_size, nb_classes, batch_size, config, initial_epoch, pre_trained_weight, augment): session_config() model = build_densenet(input_size, nb_classes, config=config) gpus = get_number_of_gpus() print('Found {} gpus'.format(gpus)) if gpus > 1: model = ModelMGPU(model, gpus) binary = nb_classes == 1 if binary: loss = binary_soft_jaccard_loss else: loss = soft_jaccard_loss model.compile(optimizer=Adam(lr=1e-3), loss=loss, metrics=['acc', binary_jaccard_distance_rounded]) train_generator, num_samples = create_generator(os.path.join( data_dir, 'train'), input_size, batch_size, nb_classes, rescale_masks=False, binary=binary, augment=augment) steps_per_epoch = num_samples // batch_size if augment: steps_per_epoch = steps_per_epoch * 4 steps_per_epoch = 1000 clr = CyclicLR(base_lr=0, max_lr=1e-1, step_size=10 * steps_per_epoch, mode='triangular') model.fit_generator(generator=train_generator, steps_per_epoch=steps_per_epoch, epochs=10, verbose=True, workers=8, callbacks=[clr]) h = clr.history lr = h['lr'] acc = h['acc'] print(lr) print() print(acc)
def _main(): annotation_path = 'annotations_updated/annotations/4000_train_updated_final.txt' log_dir = 'logs/4000_adagrad_e1e2_50x2/' classes_path = 'annotations_updated/annotations/4000_train_updated_classes.txt' anchors_path = 'model_data/tiny_yolo_anchors.txt' class_names = get_classes(classes_path) num_classes = len(class_names) anchors = get_anchors(anchors_path) input_shape = (416, 416) # multiple of 32, hw is_tiny_version = len(anchors) == 6 # default setting if is_tiny_version: model = create_tiny_model( input_shape, anchors, num_classes, freeze_body=2, weights_path='model_data/yolo_weights-tiny.h5') else: #with tf.device('/cpu:0'): model = create_model(input_shape, anchors, num_classes, freeze_body=2, weights_path='model_data/trained_weights_final.h5' ) # make sure you know what you freeze #model = multi_gpu_model(model, gpus=2) logging = TensorBoard(log_dir=log_dir) checkpoint = ModelCheckpoint( log_dir + 'ep{epoch:03d}-loss{loss:.3f}-val_loss{val_loss:.3f}.h5', monitor='val_loss', save_weights_only=True, save_best_only=True, period=3) reduce_lr = ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=3, verbose=1) early_stopping = EarlyStopping(monitor='val_loss', min_delta=0, patience=10, verbose=1) val_split = 0.1 with open(annotation_path) as f: lines = f.readlines() np.random.seed(10101) np.random.shuffle(lines) np.random.seed(None) num_val = int(len(lines) * val_split) num_train = len(lines) - num_val # Train with frozen layers first, to get a stable loss. # Adjust num epochs to your dataset. This step is enough to obtain a not bad model. if True: gpus = get_number_of_gpus() print('Found {} gpus'.format(gpus)) #if gpus > 1: #model = ModelMGPU(model, gpus) model.compile( optimizer=Adagrad(lr=1e-1), loss={ # use custom yolo_loss Lambda layer. 'yolo_loss': lambda y_true, y_pred: y_pred }) #model.compile(optimizer=Adam(lr=1e-3), losses={'concatenate_1': lambda y_true, y_pred: y_pred, 'concatenate_2': lambda y_true, y_pred: y_pred}) #model.compile(optimizer=Adam(lr=1e-3), loss=categorical_crossentropy(y_true, y_pred)) batch_size = 64 print('Train on {} samples, val on {} samples, with batch size {}.'. format(num_train, num_val, batch_size)) model.fit_generator(data_generator_wrapper(lines[:num_train], batch_size, input_shape, anchors, num_classes), steps_per_epoch=max(1, num_train // batch_size), validation_data=data_generator_wrapper( lines[num_train:], batch_size, input_shape, anchors, num_classes), validation_steps=max(1, num_val // batch_size), epochs=50, initial_epoch=0, callbacks=[logging, checkpoint]) model.save_weights(log_dir + 'trained_weights_stage_1.h5') # Unfreeze and continue training, to fine-tune. # Train longer if the result is not good. if True: for i in range(len(model.layers)): model.layers[i].trainable = True model.compile(optimizer=Adagrad(lr=1e-2), loss={ 'yolo_loss': lambda y_true, y_pred: y_pred }) # recompile to apply the change print('Unfreeze all of the layers.') batch_size = 64 # note that more GPU memory is required after unfreezing the body print('Train on {} samples, val on {} samples, with batch size {}.'. format(num_train, num_val, batch_size)) model.fit_generator( data_generator_wrapper(lines[:num_train], batch_size, input_shape, anchors, num_classes), steps_per_epoch=max(1, num_train // batch_size), validation_data=data_generator_wrapper(lines[num_train:], batch_size, input_shape, anchors, num_classes), validation_steps=max(1, num_val // batch_size), epochs=100, initial_epoch=50, callbacks=[logging, checkpoint, reduce_lr, early_stopping]) model.save_weights(log_dir + 'trained_weights_final.h5')
def run(): parser = argparse.ArgumentParser() parser.add_argument("--weights-path", type=str) parser.add_argument("--test-image", type=str, default="") parser.add_argument("--sample-images", type=str, default="") parser.add_argument("--output-path", type=str, default="") parser.add_argument("--input-size", type=int, default=713) parser.add_argument("--model-name", type=str, default="") parser.add_argument("--name", type=str, default="") args = parser.parse_args() model_name = args.model_name image_path = args.test_image input_size = args.input_size output_path = args.output_path output_name = args.name model_choices = { 'unet': build_unet, 'densenet': build_densenet } model_choice = model_choices[model_name] model = model_choice((input_size, input_size), 1) gpus = get_number_of_gpus() print('Fund {} gpus'.format(gpus)) if gpus > 1: model = ModelMGPU(model, gpus) model.compile( optimizer=Adam(lr=1e-4), loss=binary_soft_jaccard_loss, metrics=['acc', binary_jaccard_distance_rounded]) model.load_weights(args.weights_path) generator = get_generator() # load the image image = Image.open(image_path) size = image.size[0] factor = input_size / 512 image = image.resize((int(size*factor), int(size*factor))) image = np.array(image) pred = predict_img_with_smooth_windowing( image, window_size=input_size, subdivisions=2, # Minimal amount of overlap for windowing. Must be an even number. nb_classes=1, pred_func=( lambda img_batch_subdiv: model.predict( image_to_neural_input(img_batch_subdiv, generator), verbose=True ) ) ) pred = np.round(pred) pred = (pred[:, :, 0] * 255.).astype(np.uint8) pred = Image.fromarray(pred, 'L') pred = pred.resize((size, size)) pred = np.array(pred) out_path = os.path.join(output_path, output_name) print(cv2.imwrite(out_path, pred)) cheap = cheap_tiling_prediction(image, window_size=input_size, nb_classes=1, pred_func=( lambda img_batch_subdiv: model.predict( image_to_neural_input(np.array(img_batch_subdiv), generator), verbose=True ) )) cheap = np.round(cheap) cheap = (cheap[:, :, 0] * 255.).astype(np.uint8) cheap = Image.fromarray(cheap, 'L') cheap = cheap.resize((size, size)) cheap = np.array(cheap) out_path = os.path.join(output_path, '{}-cheap.tif'.format(output_name)) print(cv2.imwrite(out_path, cheap))
def run(): np.random.seed(2) tf.set_random_seed(2) data_dir = '/data/{}/' weights_dir = 'weights_train' for i, run in enumerate(runs): base_lr = run['base_lr'] max_lr = run['max_lr'] input_size = (run['input_size'], run['input_size']) weights_name = run['name'] logs_dir = 'logs/{}'.format(run['name']) batch_size = run['batch_size'] print("Running for config {}".format(run)) for j, dataset in enumerate(run['datasets']): binary = True if dataset != 'multiclass' else False nb_classes = 1 if binary else 5 print('Running training for {}'.format(dataset)) train_generator, num_samples = create_generator( os.path.join(data_dir.format(dataset), 'train'), input_size, batch_size, nb_classes=nb_classes, rescale_masks=run['rescale_masks'], binary=binary, augment=False, mean=np.array([[[0.36654497, 0.35386439, 0.30782658]]]), std=np.array([[[0.19212837, 0.19031791, 0.18903286]]])) val_generator, val_samples = create_generator( os.path.join(data_dir.format(dataset), 'val'), input_size, batch_size, nb_classes=nb_classes, rescale_masks=run['rescale_masks'], binary=binary, augment=False, mean=np.array([[[0.36654497, 0.35386439, 0.30782658]]]), std=np.array([[[0.19212837, 0.19031791, 0.18903286]]])) if run['network'] == 'unet': model = build_unet(input_size, nb_classes=nb_classes) else: model = build_densenet(input_size, nb_classes, 67) model.summary() gpus = get_number_of_gpus() print('Fund {} gpus'.format(gpus)) if gpus > 1: model = ModelMGPU(model, gpus) if binary: loss = binary_soft_jaccard_loss else: loss = soft_jaccard_loss model.compile(optimizer=Adam(), loss=loss, metrics=['acc', binary_jaccard_distance_rounded]) if run['pre_weights_name']: pre_weights_name = run['pre_weights_name'].format(dataset) weight = 'weights_train/weights.{}.h5'.format(pre_weights_name) print('Loading weights: {}'.format(weight)) model.load_weights(weight) steps_per_epoch = num_samples // batch_size cyclic = 'triangular2' cb = [ ValidationCallback( val_samples // batch_size, val_generator, binary=binary) ] + callbacks(logs_dir.format(dataset), filename=weights_name.format(dataset), weightsdir=weights_dir, monitor_val='mIOU', base_lr=base_lr, max_lr=max_lr, steps_per_epoch=steps_per_epoch, cyclic=cyclic) model.fit_generator(generator=train_generator, steps_per_epoch=steps_per_epoch, epochs=100, verbose=True, workers=8, callbacks=cb) K.clear_session()
def build_unet16(input_shape, nb_classes, lr=1e-4): """ Build a Unet16 with a VGG16 encoder pretrained on the imagenet dataset """ base_model = VGG16(weights='imagenet', include_top=False) inputs = layers.Input((input_shape[0], input_shape[1], 3)) # Block 1 x = base_model.get_layer('block1_conv1')(inputs) x = BatchNormalization(axis=-1)(x) x = base_model.get_layer('block1_conv2')(x) x1 = BatchNormalization(axis=-1)(x) x = MaxPooling2D(pool_size=(2, 2), data_format="channels_last")(x1) # Block 2 x = base_model.get_layer('block2_conv1')(x) x = BatchNormalization(axis=-1)(x) x = base_model.get_layer('block2_conv2')(x) x2 = BatchNormalization(axis=-1)(x) x = MaxPooling2D(pool_size=(2, 2), data_format="channels_last")(x2) # Block 3 x = base_model.get_layer('block3_conv1')(x) x = BatchNormalization(axis=-1)(x) x = base_model.get_layer('block3_conv2')(x) x = BatchNormalization(axis=-1)(x) x = base_model.get_layer('block3_conv3')(x) x3 = BatchNormalization(axis=-1)(x) x = MaxPooling2D(pool_size=(2, 2), data_format="channels_last")(x3) # Block 4 x = base_model.get_layer('block4_conv1')(x) x = BatchNormalization(axis=-1)(x) x = base_model.get_layer('block4_conv2')(x) x = BatchNormalization(axis=-1)(x) x = base_model.get_layer('block4_conv3')(x) x4 = BatchNormalization(axis=-1)(x) x = MaxPooling2D(pool_size=(2, 2), data_format="channels_last")(x4) # Block 5 x = base_model.get_layer('block5_conv1')(x) x = BatchNormalization(axis=-1)(x) x = base_model.get_layer('block5_conv2')(x) x = BatchNormalization(axis=-1)(x) x = base_model.get_layer('block5_conv3')(x) x5 = BatchNormalization(axis=-1)(x) x = MaxPooling2D(pool_size=(2, 2), data_format="channels_last")(x5) # Bottleneck x = down_block(x, 1024, bottleneck=True) x = up_block(x, x5, 512) x = up_block(x, x4, 512) x = up_block(x, x3, 256) x = up_block(x, x2, 128) x = up_block(x, x1, 64) x = layers.Conv2D(nb_classes, (1, 1))(x) if nb_classes == 1: activation = 'sigmoid' else: activation = 'softmax' act = Activation(activation)(x) model = Model(inputs=inputs, outputs=act) gpus = get_number_of_gpus() if gpus > 1: model = ModelMGPU(model, gpus) return model
def build_unet_old(input_shape, nb_classes, lr=1e-4): concat_axis = 3 inputs = layers.Input((input_shape[0], input_shape[1], 3)) conv1 = Conv2D(32, (3, 3), padding="same", name="conv1_1", activation="relu", data_format="channels_last", kernel_initializer='he_uniform')(inputs) conv1 = BatchNormalization(axis=-1)(conv1) conv1 = Conv2D(32, (3, 3), padding="same", activation="relu", data_format="channels_last", kernel_initializer='he_uniform')(conv1) conv1 = BatchNormalization(axis=-1)(conv1) pool1 = MaxPooling2D(pool_size=(2, 2), data_format="channels_last")(conv1) conv2 = Conv2D(64, (3, 3), padding="same", activation="relu", data_format="channels_last", kernel_initializer='he_uniform')(pool1) conv2 = BatchNormalization(axis=-1)(conv2) conv2 = Conv2D(64, (3, 3), padding="same", activation="relu", data_format="channels_last", kernel_initializer='he_uniform')(conv2) conv2 = BatchNormalization(axis=-1)(conv2) pool2 = MaxPooling2D(pool_size=(2, 2), data_format="channels_last")(conv2) conv3 = Conv2D(128, (3, 3), padding="same", activation="relu", data_format="channels_last", kernel_initializer='he_uniform')(pool2) conv3 = BatchNormalization(axis=-1)(conv3) conv3 = Conv2D(128, (3, 3), padding="same", activation="relu", data_format="channels_last", kernel_initializer='he_uniform')(conv3) conv3 = BatchNormalization(axis=-1)(conv3) pool3 = MaxPooling2D(pool_size=(2, 2), data_format="channels_last")(conv3) conv4 = Conv2D(256, (3, 3), padding="same", activation="relu", data_format="channels_last", kernel_initializer='he_uniform')(pool3) conv4 = BatchNormalization(axis=-1)(conv4) conv4 = Conv2D(256, (3, 3), padding="same", activation="relu", data_format="channels_last", kernel_initializer='he_uniform')(conv4) conv4 = BatchNormalization(axis=-1)(conv4) pool4 = MaxPooling2D(pool_size=(2, 2), data_format="channels_last")(conv4) conv5 = Conv2D(512, (3, 3), padding="same", activation="relu", data_format="channels_last", kernel_initializer='he_uniform')(pool4) conv5 = BatchNormalization(axis=-1)(conv5) conv5 = Conv2D(512, (3, 3), padding="same", activation="relu", data_format="channels_last", kernel_initializer='he_uniform')(conv5) conv5 = BatchNormalization(axis=-1)(conv5) pool5 = MaxPooling2D(pool_size=(2, 2), data_format="channels_last")(conv5) convbott = Conv2D(1024, (3, 3), padding="same", activation="relu", data_format="channels_last", kernel_initializer='he_uniform')(pool5) convbott = BatchNormalization(axis=-1)(convbott) convbott = Conv2D(1024, (3, 3), padding="same", activation="relu", data_format="channels_last", kernel_initializer='he_uniform')(convbott) convbott = BatchNormalization(axis=-1)(convbott) up_convbott = UpSampling2D(size=(2, 2), data_format="channels_last")(convbott) ch, cw = get_crop_shape(conv5, up_convbott) crop_conv5 = Cropping2D(cropping=(ch, cw), data_format="channels_last")(conv5) upbott = concatenate([up_convbott, crop_conv5], axis=concat_axis) convbott1 = Dropout(0.2)(upbott) convbott1 = Conv2D(512, (3, 3), padding="same", activation="relu", data_format="channels_last", kernel_initializer='he_uniform')(convbott1) convbott1 = Conv2D(512, (3, 3), padding="same", activation="relu", data_format="channels_last", kernel_initializer='he_uniform')(convbott1) up_convbott1 = UpSampling2D(size=(2, 2), data_format="channels_last")(convbott1) ch, cw = get_crop_shape(conv4, up_convbott1) crop_conv4 = Cropping2D(cropping=(ch, cw), data_format="channels_last")(conv4) up6 = concatenate([up_convbott1, crop_conv4], axis=concat_axis) conv6 = Dropout(0.2)(up6) conv6 = Conv2D(256, (3, 3), padding="same", activation="relu", data_format="channels_last", kernel_initializer='he_uniform')(conv6) conv6 = Conv2D(256, (3, 3), padding="same", activation="relu", data_format="channels_last", kernel_initializer='he_uniform')(conv6) up_conv6 = UpSampling2D(size=(2, 2), data_format="channels_last")(conv6) ch, cw = get_crop_shape(conv3, up_conv6) crop_conv3 = Cropping2D(cropping=(ch, cw), data_format="channels_last")(conv3) up7 = concatenate([up_conv6, crop_conv3], axis=concat_axis) conv7 = Dropout(0.2)(up7) conv7 = Conv2D(128, (3, 3), padding="same", activation="relu", data_format="channels_last", kernel_initializer='he_uniform')(conv7) conv7 = Conv2D(128, (3, 3), padding="same", activation="relu", data_format="channels_last", kernel_initializer='he_uniform')(conv7) up_conv7 = UpSampling2D(size=(2, 2), data_format="channels_last")(conv7) ch, cw = get_crop_shape(conv2, up_conv7) crop_conv2 = Cropping2D(cropping=(ch, cw), data_format="channels_last")(conv2) up8 = concatenate([up_conv7, crop_conv2], axis=concat_axis) conv8 = Dropout(0.2)(up8) conv8 = Conv2D(64, (3, 3), padding="same", activation="relu", data_format="channels_last", kernel_initializer='he_uniform')(conv8) conv8 = Conv2D(64, (3, 3), padding="same", activation="relu", data_format="channels_last", kernel_initializer='he_uniform')(conv8) up_conv8 = UpSampling2D(size=(2, 2), data_format="channels_last")(conv8) ch, cw = get_crop_shape(conv1, up_conv8) crop_conv1 = Cropping2D(cropping=(ch, cw), data_format="channels_last")(conv1) up9 = concatenate([up_conv8, crop_conv1], axis=concat_axis) conv9 = Dropout(0.2)(up9) conv9 = Conv2D(32, (3, 3), padding="same", activation="relu", data_format="channels_last", kernel_initializer='he_uniform')(conv9) conv9 = Conv2D(32, (3, 3), padding="same", activation="relu", data_format="channels_last", kernel_initializer='he_uniform')(conv9) ch, cw = get_crop_shape(inputs, conv9) conv9 = layers.ZeroPadding2D(padding=((ch[0], ch[1]), (cw[0], cw[1])))(conv9) conv10 = layers.Conv2D(nb_classes, (1, 1))(conv9) activation = 'softmax' if nb_classes == 1: activation = 'sigmoid' act = Activation(activation)(conv10) model = Model(inputs=inputs, outputs=act) gpus = get_number_of_gpus() if gpus > 1: model = ModelMGPU(model, gpus) return model
def pred(): image_path = '/data/{}/test' for dataset in datasets: im_path = image_path.format(dataset['name']) for model in models: input_size = model['input_size'] generator, _ = create_generator( im_path, (input_size, input_size), dataset['size'], 1, rescale_masks=True, with_file_names=True, binary=True, mean=np.array([[[0.36654497, 0.35386439, 0.30782658]]]), std=np.array([[[0.19212837, 0.19031791, 0.18903286]]]) ) images, masks, file_names = next(generator) m = model['method']((input_size, input_size), 1) gpus = get_number_of_gpus() if gpus > 1: m = ModelMGPU(m, gpus) m.compile( optimizer=Adam(lr=1e-4), loss=binary_soft_jaccard_loss, metrics=['acc', binary_jaccard_distance_rounded]) weights_path = 'weights_train/weights.{}-{}-final-finetune.h5'.format(model['name'], dataset['name']) m.load_weights(weights_path) probs = m.predict(images, verbose=1) probs = np.round(probs) iou = batch_general_jaccard(masks, probs) f1 = f1_score(masks, probs) print('Mean IOU for {} on {}: {}'.format(model['name'], dataset['name'], np.mean(iou))) print('F1 score for {} on {}: {}'.format(model['name'], dataset['name'], f1)) # wow such hack from keras_utils.prediction import get_real_image, get_geo_frame, geo_reference_raster for i, (prob, mask) in enumerate(zip(probs, masks)): if i > 200: break raster = get_real_image(im_path, file_names[i], use_gdal=True) R = raster.GetRasterBand(1).ReadAsArray() G = raster.GetRasterBand(2).ReadAsArray() B = raster.GetRasterBand(3).ReadAsArray() img = np.zeros((512, 512, 3)) img[:, :, 0] = B img[:, :, 1] = G img[:, :, 2] = R prob = np.round(prob) prob = (prob[:, :, 0] * 255.).astype(np.uint8) mask = (mask[:, :, 0] * 255.).astype(np.uint8) pred_name = "pred-{}.tif".format(i) out_path = '/data/finalpreds/{}/{}'.format(model['name'], dataset['name']) pred_save_path = "{}/{}".format(out_path, pred_name) cv2.imwrite(pred_save_path, prob) cv2.imwrite("{}/image-{}.tif".format(out_path, i), img) cv2.imwrite("{}/mask-{}.tif".format(out_path, i), mask) try: # Get coordinates for corresponding image ulx, scalex, skewx, uly, skewy, scaley = get_geo_frame(raster) # Geo reference newly created raster geo_reference_raster( pred_save_path, [ulx, scalex, skewx, uly, skewy, scaley] ) except ValueError as e: print("Was not able to reference image at path: {}".format(pred_save_path)) K.clear_session()
def run(): parser = argparse.ArgumentParser() parser.add_argument("--weights-path", type=str) parser.add_argument("--epoch-number", type=int, default=5) parser.add_argument("--test-images", type=str, default="") parser.add_argument("--output-path", type=str, default="") parser.add_argument("--input-size", type=int, default=713) parser.add_argument("--batch-size", type=int, default=713) parser.add_argument("--model-name", type=str, default="standard") parser.add_argument("--save-imgs", type=bool, default=True) args = parser.parse_args() model_name = args.model_name images_path = args.test_images input_size = args.input_size batch_size = args.batch_size save_imgs = args.save_imgs all_probs = {} model_choices = { 'densenet': build_densenet, 'unet': build_unet } model_choice = model_choices[model_name] generator, _ = create_generator( images_path, (input_size, input_size), batch_size, 5, rescale_masks=True, with_file_names=True, binary=False, mean=np.array([[[0.36654497, 0.35386439, 0.30782658]]]), std=np.array([[[0.19212837, 0.19031791, 0.18903286]]]) ) images, masks, file_names = next(generator) for dataset in datasets: model = model_choice((input_size, input_size), 1) gpus = get_number_of_gpus() print('Fund {} gpus'.format(gpus)) if gpus > 1: model = ModelMGPU(model, gpus) model.compile( optimizer=Adam(lr=1e-4), loss=binary_soft_jaccard_loss, metrics=['acc', binary_jaccard_distance_rounded]) model.load_weights(args.weights_path.format(dataset)) probs = model.predict(images, verbose=1) probs = np.round(probs) # iou = batch_general_jaccard(masks, probs, binary=True) # f1 = K.eval(f1_score(K.variable(masks), K.variable(probs))) # print('Mean IOU for {}: {}'.format(dataset, np.mean(iou))) # print('F1 score for {}: {}'.format(dataset, f1)) all_probs[dataset] = probs final_prob = None for i, key in enumerate(all_probs): prob = all_probs[key] prob[prob == 1] = scores[key] if i == 0: # First iteration final_prob = prob continue final_prob = np.maximum.reduce([final_prob, prob]) masks = np.argmax(masks, axis=2) iou = batch_general_jaccard(masks, final_prob) f1 = K.eval(f1_score(K.variable(masks), K.variable(final_prob))) print('Mean IOU for {}: {}'.format('multiclass', np.mean(iou))) print('F1 score for {}: {}'.format('multiclass', f1)) if not save_imgs: return # wow such hack from keras_utils.prediction import get_real_image, get_geo_frame, geo_reference_raster for i, prob in enumerate(final_prob): mask = np.argmax(masks[i], axis=2) raster = get_real_image(os.path.join(images_path, 'multiclass', 'test'), file_names[i], use_gdal=True) R = raster.GetRasterBand(1).ReadAsArray() G = raster.GetRasterBand(2).ReadAsArray() B = raster.GetRasterBand(3).ReadAsArray() img = np.zeros((512, 512, 3)) img[:, :, 0] = B img[:, :, 1] = G img[:, :, 2] = R seg_pred = np.zeros((input_size, input_size, 3)) seg_mask = np.zeros((input_size, input_size, 3)) for c in range(5): seg_pred[:, :, 0] += ((prob[:, :, 0] == c) * (class_color_map[c][2])).astype('uint8') seg_pred[:, :, 1] += ((prob[:, :, 0] == c) * (class_color_map[c][1])).astype('uint8') seg_pred[:, :, 2] += ((prob[:, :, 0] == c) * (class_color_map[c][0])).astype('uint8') seg_mask[:, :, 0] += ((mask[:, :] == c) * (class_color_map[c][2])).astype('uint8') seg_mask[:, :, 1] += ((mask[:, :] == c) * (class_color_map[c][1])).astype('uint8') seg_mask[:, :, 2] += ((mask[:, :] == c) * (class_color_map[c][0])).astype('uint8') pred_name = "pred-{}.tif".format(i) pred_save_path = "{}/{}".format(args.output_path, pred_name) cv2.imwrite(pred_save_path, seg_pred) cv2.imwrite("{}/mask-{}.tif".format(args.output_path, i), seg_mask) cv2.imwrite("{}/image-{}.tif".format(args.output_path, i), img) try: # Get coordinates for corresponding image ulx, scalex, skewx, uly, skewy, scaley = get_geo_frame(raster) # Geo reference newly created raster geo_reference_raster( pred_save_path, [ulx, scalex, skewx, uly, skewy, scaley] ) except ValueError as e: print("Was not able to reference image at path: {}".format(pred_save_path))
def run(): parser = argparse.ArgumentParser() parser.add_argument("--weights-path", type=str) parser.add_argument("--test-image", type=str, default="") parser.add_argument("--sample-images", type=str, default="") parser.add_argument("--output-path", type=str, default="") parser.add_argument("--input-size", type=int, default=713) parser.add_argument("--model-name", type=str, default="") parser.add_argument("--name", type=str, default="") parser.add_argument("--mask", type=str, default="") args = parser.parse_args() model_name = args.model_name image_path = args.test_image input_size = args.input_size output_path = args.output_path file_name = args.name mask_path = args.mask nb_classes = 5 model_choices = {'unet': build_unet, 'densenet': build_densenet} model_choice = model_choices[model_name] model = model_choice((input_size, input_size), nb_classes) gpus = get_number_of_gpus() print('Fund {} gpus'.format(gpus)) if gpus > 1: model = ModelMGPU(model, gpus) model.compile(optimizer=Adam(lr=1e-4), loss=binary_soft_jaccard_loss, metrics=['acc', binary_jaccard_distance_rounded]) model.load_weights(args.weights_path) generator = get_generator() # load the image image = Image.open(image_path) size = image.size[0] factor = input_size / 512 image = image.resize((int(size * factor), int(size * factor))) image = np.array(image) pred = predict_img_with_smooth_windowing( image, window_size=input_size, subdivisions= 2, # Minimal amount of overlap for windowing. Must be an even number. nb_classes=nb_classes, pred_func=(lambda img_batch_subdiv: model.predict( image_to_neural_input(img_batch_subdiv, generator), verbose=True))) pred = np.argmax(pred, axis=2) pred_color = np.zeros((pred.shape[0], pred.shape[0], 3)) if mask_path: mask = Image.open(mask_path).convert('L') mask = mask.resize((pred.shape[0], pred.shape[0])) mask = np.array(mask) mask = np.reshape(mask, (1, mask.shape[0], mask.shape[1])) p = np.reshape(pred, (1, pred.shape[0], pred.shape[1])) print('mIOU:', batch_general_jaccard(mask, p)) print('F1:', batch_classwise_f1_score(mask, p)) class_color_map = { 0: [237, 237, 237], # Empty 1: [254, 241, 179], # Roads 2: [116, 173, 209], # Water 3: [193, 235, 176], # Grass 4: [170, 170, 170] # Buildings } for c in range(nb_classes): pred_color[:, :, 0] += ((pred[:, :] == c) * (class_color_map[c][2])).astype('uint8') pred_color[:, :, 1] += ((pred[:, :] == c) * (class_color_map[c][1])).astype('uint8') pred_color[:, :, 2] += ((pred[:, :] == c) * (class_color_map[c][0])).astype('uint8') out_path = os.path.join(output_path, file_name) print(cv2.imwrite(out_path, pred_color)) cheap = cheap_tiling_prediction( image, window_size=input_size, nb_classes=nb_classes, pred_func=(lambda img_batch_subdiv: model.predict( image_to_neural_input(np.array(img_batch_subdiv), generator), verbose=True))) cheap = np.argmax(cheap, axis=2) cheap_color = np.zeros((cheap.shape[0], cheap.shape[1], 3)) if mask_path: mask = Image.open(mask_path).convert('L') mask = mask.resize((cheap.shape[0], cheap.shape[0])) mask = np.array(mask) mask = np.reshape(mask, (1, mask.shape[0], mask.shape[1])) p = np.reshape(cheap, (1, cheap.shape[0], cheap.shape[1])) print('mIOU:', batch_general_jaccard(mask, p)) print('F1:', batch_classwise_f1_score(mask, p)) for c in range(nb_classes): cheap_color[:, :, 0] += ((cheap[:, :] == c) * (class_color_map[c][2])).astype('uint8') cheap_color[:, :, 1] += ((cheap[:, :] == c) * (class_color_map[c][1])).astype('uint8') cheap_color[:, :, 2] += ((cheap[:, :] == c) * (class_color_map[c][0])).astype('uint8') out_path = os.path.join(output_path, 'cheap-{}'.format(file_name)) print(cv2.imwrite(out_path, cheap_color))
def train_densenet(data_dir, logdir, weights_dir, weights_name, input_size, nb_classes, batch_size, config, initial_epoch, pre_trained_weight, augment): session_config() model = build_densenet(input_size, nb_classes, config=config) model.summary() gpus = get_number_of_gpus() print('Found {} gpus'.format(gpus)) if gpus > 1: model = ModelMGPU(model, gpus) is_binary = nb_classes == 1 if is_binary: loss = binary_soft_jaccard_loss else: loss = soft_jaccard_loss model.compile(optimizer=Adam(lr=1e-3), loss=loss, metrics=['acc', binary_jaccard_distance_rounded]) train_generator, num_samples = create_generator( os.path.join(data_dir, 'train'), input_size, batch_size, nb_classes, rescale_masks=True, binary=is_binary, augment=False, mean=np.array([[[0.42800662, 0.40565866, 0.3564895]]]), std=np.array([[[0.19446792, 0.1984272, 0.19501258]]])) val_generator, val_samples = create_generator( os.path.join(data_dir, 'val'), input_size, batch_size, nb_classes, rescale_masks=True, binary=is_binary, augment=False, mean=np.array([[[0.42800662, 0.40565866, 0.3564895]]]), std=np.array([[[0.19446792, 0.1984272, 0.19501258]]])) if pre_trained_weight: print('Loading weights: {}'.format(pre_trained_weight)) model.load_weights(pre_trained_weight) steps_per_epoch = num_samples // batch_size if augment: steps_per_epoch = steps_per_epoch * 4 base_lr = 0.00002 max_lr = 0.00055 cb = [ ValidationCallback(val_samples // batch_size, val_generator, is_binary) ] + callbacks(logdir, filename=weights_name, weightsdir=weights_dir, monitor_val='mIOU', base_lr=base_lr, max_lr=max_lr, steps_per_epoch=steps_per_epoch, cyclic='triangular2') model.fit_generator(generator=train_generator, steps_per_epoch=steps_per_epoch, epochs=100, verbose=True, workers=8, callbacks=cb, initial_epoch=initial_epoch)
def run(args): n_classes = args.classes model_name = args.model_name images_path = args.test_images input_size = args.input_size batch_size = args.batch_size no_save_imgs = args.no_save_imgs model_choices = { 'unet': build_unet, 'densenet': build_densenet, 'pspnet': build_pspnet } model_choice = model_choices[model_name] model = model_choice((input_size, input_size), n_classes) gpus = get_number_of_gpus() print('Fund {} gpus'.format(gpus)) if gpus > 1: model = ModelMGPU(model, gpus) model.compile(optimizer=Adam(lr=1e-4), loss=binary_soft_jaccard_loss, metrics=['acc', binary_jaccard_distance_rounded]) model.load_weights(args.weights_path) binary = n_classes == 1 generator, samples = create_generator( images_path, (input_size, input_size), batch_size, nb_classes=n_classes, rescale_masks=False, with_file_names=True, binary=binary, augment=False, mean=np.array([[[0.36654497, 0.35386439, 0.30782658]]]), std=np.array([[[0.19212837, 0.19031791, 0.18903286]]])) steps = samples // batch_size f1s = [] ious = [] for i in range(steps): images, masks, file_names = next(generator) probs = model.predict(images, verbose=1) probs = np.argmax(probs, axis=3) masks = np.argmax(masks, axis=3) iou = batch_general_jaccard(masks, probs) f1 = batch_classwise_f1_score(masks, probs) ious.append(iou) f1s.append(f1) if no_save_imgs: continue for i, prob in enumerate(probs): result = prob mask_result = masks[i] # img = get_real_image(images_path, file_names[i]) raster = get_real_image(images_path, file_names[i], use_gdal=True) R = raster.GetRasterBand(1).ReadAsArray() G = raster.GetRasterBand(2).ReadAsArray() B = raster.GetRasterBand(3).ReadAsArray() img = np.zeros((512, 512, 3)) img[:, :, 0] = B img[:, :, 1] = G img[:, :, 2] = R seg_img = np.zeros((input_size, input_size, 3)) seg_mask = np.zeros((input_size, input_size, 3)) for c in range(n_classes): seg_img[:, :, 0] += ((result[:, :] == c) * (class_color_map[c][2])).astype('uint8') seg_img[:, :, 1] += ((result[:, :] == c) * (class_color_map[c][1])).astype('uint8') seg_img[:, :, 2] += ((result[:, :] == c) * (class_color_map[c][0])).astype('uint8') seg_mask[:, :, 0] += ((mask_result[:, :] == c) * (class_color_map[c][2])).astype('uint8') seg_mask[:, :, 1] += ((mask_result[:, :] == c) * (class_color_map[c][1])).astype('uint8') seg_mask[:, :, 2] += ((mask_result[:, :] == c) * (class_color_map[c][0])).astype('uint8') pred_name = "pred-{}.tif".format(i) pred_save_path = "{}/{}".format(args.output_path, pred_name) cv2.imwrite(pred_save_path, seg_img) cv2.imwrite("{}/mask-{}.tif".format(args.output_path, i), seg_mask) cv2.imwrite("{}/image-{}.tif".format(args.output_path, i), img) try: # Get coordinates for corresponding image ulx, scalex, skewx, uly, skewy, scaley = get_geo_frame(raster) # Geo reference newly created raster geo_reference_raster(pred_save_path, [ulx, scalex, skewx, uly, skewy, scaley]) except ValueError as e: print("Was not able to reference image at path: {}".format( pred_save_path)) print('Mean IOU: {}'.format(np.mean(ious))) print('F1 score: {}'.format(np.mean(f1s)))