def get_RetinaNet_model(): from keras.utils import custom_object_scope from keras_resnet.layers import BatchNormalization from keras_retinanet.layers import UpsampleLike, Anchors, RegressBoxes, ClipBoxes, FilterDetections from keras_retinanet.initializers import PriorProbability from keras_retinanet import models from keras_retinanet.models.retinanet import retinanet_bbox custom_objects = { 'BatchNormalization': BatchNormalization, 'UpsampleLike': UpsampleLike, 'Anchors': Anchors, 'RegressBoxes': RegressBoxes, 'PriorProbability': PriorProbability, 'ClipBoxes': ClipBoxes, 'FilterDetections': FilterDetections, } with custom_object_scope(custom_objects): backbone = models.backbone('resnet50') model = backbone.retinanet(500) prediction_model = retinanet_bbox(model=model) # prediction_model.load_weights("...your weights here...") return prediction_model, custom_objects
def test_lengths(config): """Assert that a csv generator and tfrecords create the same number of images in a epoch""" created_records = tfrecords.create_tfrecords( annotations_file="tests/output/testfile_tfrecords.csv", class_file="tests/output/classes.csv", image_min_side=config["image-min-side"], backbone_model=config["backbone"], size=100, savedir="tests/output/") # tfdata tf_filenames = find_tf_filenames(path="tests/output/*.tfrecord") # keras generator backbone = models.backbone(config["backbone"]) generator = csv_generator.CSVGenerator( csv_data_file="tests/output/testfile_tfrecords.csv", csv_class_file="tests/output/classes.csv", image_min_side=config["image-min-side"], preprocess_image=backbone.preprocess_image, ) fit_genertor_length = generator.size() assert len(tf_filenames) == fit_genertor_length
def main(args=None): from keras import backend as K # parse arguments if args is None: args = sys.argv[1:] args = parse_args(args) print('Arguments: {}'.format(args)) # create object that stores backbone information backbone = models.backbone(args.backbone) # make sure keras is the minimum required version check_keras_version() # optionally choose specific GPU if args.gpu: os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu keras.backend.tensorflow_backend.set_session(get_session()) # create the generators validation_generator = create_generators(args, backbone.preprocess_image) # create the model weights = args.weights # default to imagenet if nothing else is specified if weights is None and args.imagenet_weights: weights = backbone.download_imagenet() print('Creating model, this may take a second...') model, prediction_model = create_models( backbone_retinanet=backbone.retinanet, num_classes=validation_generator.num_classes(), weights=weights, multi_gpu=args.multi_gpu, freeze_backbone=args.freeze_backbone) # evaluate model print('Evaluating model from {}, this may take a while...'.format( args.weights)) average_precisions = evaluate( validation_generator, prediction_model, iou_threshold=0.5, score_threshold=0.05, max_detections=300, ) # print evaluation present_classes = 0 precision = 0 for label, (average_precision, num_annotations) in average_precisions.items(): print('{:.0f} instances of class'.format(num_annotations), validation_generator.label_to_name(label), 'with average precision: {:.4f}'.format(average_precision)) if num_annotations > 0: present_classes += 1 precision += average_precision print('mAP: {:.4f}'.format(precision / present_classes))
def use_release(self, gpus=1): '''Use the latest DeepForest model release from github and load model. Optionally download if release doesn't exist Returns: model (object): A trained keras model gpus: number of gpus to parallelize, default to 1 ''' #Download latest model from github release release_tag, self.weights = utilities.use_release() #load saved model and tag release self.__release_version__ = release_tag print("Loading pre-built model: {}".format(release_tag)) if gpus == 1: with warnings.catch_warnings(): #Suppress compilte warning, not relevant here warnings.filterwarnings("ignore", category=UserWarning) self.model = utilities.read_model(self.weights, self.config) #Convert model self.prediction_model = convert_model(self.model) elif gpus > 1: backbone = models.backbone(self.config["backbone"]) n_classes = len(self.labels.keys()) self.model, self.training_model, self.prediction_model = create_models( backbone.retinanet, num_classes=n_classes, weights=self.weights, multi_gpu=gpus) #add to config self.config["weights"] = self.weights
def __init__(self, backbone="resnet50", random_transform=False, batch_size=2, step=100, epoch=40, anchor_settings=None): """ Initializer Args: backbone string indicate which backbone network to use (only for ones defined in keras-retinanet) random_transform boolean indicate whether image is randomly transformed when training batch_size number of images sent for each step during training step number of steps(batches) to run for each epoch during training epoch number of epochs for this training anchor_settings a list of lists indicate anchor box parameters. please reference keras-retinanet's document for how to set up anchor box parameters """ check_keras_version() self._backbone_name = backbone self._backbone = models.backbone(backbone) self._img_preprocessor = self._backbone.preprocess_image self._batch_size = batch_size self._step = step self._epoch = epoch if random_transform: self._transform_generator = random_transform_generator( min_rotation=-0.1, max_rotation=0.1, min_translation=(-0.1, -0.1), max_translation=(0.1, 0.1), min_shear=-0.1, max_shear=0.1, min_scaling=(0.9, 0.9), max_scaling=(1.1, 1.1), flip_x_chance=0.5, flip_y_chance=0.5, ) else: self._transform_generator = random_transform_generator( flip_x_chance=0.5) self._common_args = { 'batch_size': batch_size, 'preprocess_image': self._img_preprocessor } if anchor_settings: self._anchor_params = AnchorParameters(*anchor_settings) else: self._anchor_params = AnchorParameters.default
def _load_model_with_nms(self, test_args): """ This is mostly copied fomr retinanet.py """ backbone_name = test_args.get('DETECTOR', 'backbone') print(backbone_name) print(test_args.get('DETECTOR', 'detector_model_path')) model = keras.models.load_model( str(test_args.get('DETECTOR', 'detector_model_path')), custom_objects=backbone(backbone_name).custom_objects) # compute the anchors features = [ model.get_layer(name).output for name in ['P3', 'P4', 'P5', 'P6', 'P7'] ] anchors = build_anchors(AnchorParameters.default, features) # we expect the anchors, regression and classification values as first # output print(len(model.outputs)) regression = model.outputs[0] classification = model.outputs[1] print(classification.shape[1]) print(regression.shape) # "other" can be any additional output from custom submodels, # by default this will be [] other = model.outputs[2:] # apply predicted regression to anchors boxes = layers.RegressBoxes(name='boxes')([anchors, regression]) boxes = layers.ClipBoxes(name='clipped_boxes')( [model.inputs[0], boxes]) # filter detections (apply NMS / score threshold / select top-k) #detections = layers.FilterDetections( # nms=True, # name='filtered_detections', # nms_threshold = test_args.getfloat('DETECTOR','nms_threshold'), # score_threshold = test_args.getfloat('DETECTOR','det_threshold'), # max_detections = test_args.getint('DETECTOR', 'max_detections') # )([boxes, classification] + other) detections = layers.filter_detections.filter_detections( boxes=boxes, classification=classification, other=other, nms=True, nms_threshold=test_args.getfloat('DETECTOR', 'nms_threshold'), score_threshold=test_args.getfloat('DETECTOR', 'det_threshold'), max_detections=test_args.getint('DETECTOR', 'max_detections')) outputs = detections # construct the model return keras.models.Model(inputs=model.inputs, outputs=outputs, name='retinanet-bbox')
def main(args=None): args = parse_args(args) action = args.action backbone = models.backbone("resnet50") modelpath = args.model_path cocopath = args.coco_path generator = create_generator(args, backbone.preprocess_image) quantize_retinanet(modelpath, cocopath, action) evaluate(generator, action, args.score_threshold)
def main(args=None): # parse arguments if args is None: args = sys.argv[1:] args = parse_args(args) # optionally choose specific GPU # if args.gpu: # os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu with tf.device('/device:GPU:3'): config = tf.ConfigProto(allow_soft_placement=True, log_device_placement=False, device_count={'CPU': 1, 'GPU': 1}) config.gpu_options.allow_growth = True session = tf.Session(config=config) keras.backend.set_session(session) # create the generators val_generator = create_val_generator(args) weights = args.weights # default to imagenet if nothing else is specified backbone = models.backbone(args.backbone) print('Creating model, this may take a second...') # model = model_with_weights(backbone(val_generator.num_classes(), num_anchors=None, modifier=freeze_model), weights=weights, skip_mismatch=True) model, training_model, prediction_model = create_models( backbone_retinanet=backbone.retinanet, num_classes=val_generator.num_classes(), weights=weights, multi_gpu=args.multi_gpu, freeze_backbone=args.freeze_backbone, lr=args.lr, config=args.config ) # print model summary print(model.summary()) evaluation = Evaluate(val_generator, weighted_average=args.weighted_average, eval_batch_size=args.val_batch_size) evaluation = RedirectModel(evaluation, prediction_model) generator = val_generator iou_threshold = 0.5 score_threshold = 0.05 max_detections = 100 save_path = None weighted_average = False verbose = True eval_batch_size = 16 from keras_retinanet.utils.sail_eval_data_generator import SAIL_EvalDataGenerator eval_batch_datagen = SAIL_EvalDataGenerator(generator, batch_size=eval_batch_size) boxes, scores, labels = model.predict_generator(eval_batch_datagen, steps=len(eval_batch_datagen), verbose=True, workers=0, use_multiprocessing=False)[:3]
def main(args=None): # parse arguments if args is None: args = sys.argv[1:] args = parse_args(args) # create object that stores backbone information backbone = models.backbone(args.backbone) # optionally load config parameters if args.config: args.config = read_config_file(args.config) # create the generators train_generator = create_generators(args, backbone.preprocess_image) # create the model if args.snapshot is not None: print('Loading model') model = models.load_model(args.snapshot, backbone_name=args.backbone) training_model = model anchor_params = None if args.config and 'anchor_parameters' in args.config: anchor_params = parse_anchor_parameters(args.config) prediction_model = retinanet_bbox(model=model, anchor_params=anchor_params) else: weights = args.weights if weights is None and args.imagenet_weights: weights = backbone.download_imagenet() print('Creating model') model, training_model, prediction_model = create_models( backbone_retinanet=backbone.retinanet, num_classes=train_generator.num_classes(), weights=weights, multi_gpu=args.multi_gpu, freeze_backbone=args.freeze_backbone, lr=args.lr, config=args.config) # this lets the generator compute backbone layer shapes using the actual backbone model if 'densenet' in args.backbone: train_generator.compute_shapes = make_shapes_callback(model) # create the callbacks callbacks = create_callbacks(model, training_model, prediction_model, args) # start training return training_model.fit_generator( generator=train_generator, steps_per_epoch=train_generator.size() // args.batch_size, epochs=args.epochs, verbose=1, callbacks=callbacks)
def load_retina(weights: str, num_classes: int, anchors_wrap: AnchorParametersWrap, backbone_name: str) -> Model: """ Loads retinanet with weights. """ ret = models.backbone(backbone_name=backbone_name).retinanet( num_classes=num_classes, num_anchors=anchors_wrap.num_anchors) ret.load_weights(weights) ret = models.convert_model(model=ret, nms=True, class_specific_filter=True, anchor_params=anchors_wrap.anchors) return ret
def get_joint_detection_model(model_path, model_type): """ Input -> Model path for the object detection model Model type-> Foot or Hand Output -> Inference model for getting the predictions on test images """ # config_file_path = '/usr/local/bin/config' if model_type == 'Foot_detection': # with open('/usr/local/bin/src/config.ini','w') as f: # f.write('[anchor_parameters]\nsizes = 32 64 128 256 512 1024\nstrides = 8 16 32 64 128 256\nratios = 1.2 1.5 2 2.5 3\nscales =1 1.5 2\n') model, training_model, prediction_model = create_models( backbone_retinanet=backbone('resnet50').retinanet, num_classes=5, weights=None, multi_gpu=False, freeze_backbone=True, lr=1e-3, config=read_config_file('/usr/local/bin/Config files/config_foot.ini')) training_model.load_weights(model_path) infer_model = convert_model(training_model, anchor_params = parse_anchor_parameters(read_config_file('/usr/local/bin/Config files/config_foot.ini'))) elif model_type == 'Hand_detection': # with open('/usr/local/bin/src/config.ini','w') as f: # f.write('[anchor_parameters]\nsizes = 32 64 128 256 512 1024\nstrides = 8 16 32 64 128 256\nratios = 1 1.5 2 2.5 3\nscales = 1 1.2 1.6\n') model, training_model, prediction_model = create_models( backbone_retinanet=backbone('resnet50').retinanet, num_classes=6, weights=None, multi_gpu=False, freeze_backbone=True, lr=1e-3, config=read_config_file('/usr/local/bin/Config files/config_hand.ini')) training_model.load_weights(model_path) infer_model = convert_model(training_model, anchor_params = parse_anchor_parameters(read_config_file('/usr/local/bin/Config files/config_hand.ini'))) return infer_model
def retinanet_train(tiny=False): labels_path = bdd100k_labels_path val_json = labels_path + 'bdd100k_labels_images_val.json' train_json = labels_path + 'bdd100k_labels_images_train.json' val_annot = labels_path + 'val_annotations.csv' train_annot = labels_path + 'train_annotations.csv' num_data = 70000 classes = bu.annotate(val_json, val_annot, labels_path, bdd100k_val_path) cl_map_path = bu.class_mapping(classes, output_csv=labels_path + 'class_mapping.csv') bu.annotate(train_json, train_annot, bdd100k_labels_path, bdd100k_train_path) # Hyper-parameters batch_size = 1 steps_per_epoch = np.ceil(num_data / batch_size) for m in models: print('Generating %s backbone...' % m) backbone = kr_models.backbone(m) weights = backbone.download_imagenet() print('Creating generators...') tr_gen, val_gen = mt.create_generators( train_annotations=train_annot, val_annotations=val_annot, class_mapping=cl_map_path, base_dir='', preprocess_image=backbone.preprocess_image, batch_size=batch_size) print('Creating models...') model, training_model, prediction_model = kr_train.create_models( backbone.retinanet, tr_gen.num_classes(), weights) print('Creating callbacks...') callbacks = mt.create_callbacks(model, batch_size, 'test', tensorboard_dir=log_path) print('Training...') training_model.fit_generator( generator=tr_gen, steps_per_epoch=steps_per_epoch, # 10000, epochs=2, verbose=1, callbacks=callbacks, workers=4, # 1 use_multiprocessing=True, # False, max_queue_size=10, validation_data=val_gen)
def create_model(): model_path = Path( '/data/students_home/fschipani/thesis/keras-retinanet/snapshots/resnet50_coco_best_v2.1.0.h5' ) model = models.backbone('resnet50').retinanet( num_classes=train_generator.num_classes()) model.load_weights(model_path, by_name=True, skip_mismatch=True) model.compile(loss={ 'regression': smooth_l1(), 'classification': focal() }, optimizer=keras.optimizers.adam(lr=1e-5, clipnorm=0.001)) return model
def load_training_model(num_classes, args): backbone = models.backbone(args.backbone) weights = backbone.download_imagenet() model, training_model, prediction_model = create_models( backbone_retinanet=backbone.retinanet, num_classes=num_classes, weights=weights, multi_gpu=args.multi_gpu, freeze_backbone=args.freeze_backbone, lr=args.lr, config=args.config) return training_model
def retinanet_tiny_train(): labels_path = bdd100k_labels_path val_json = labels_path + 'bdd100k_labels_images_val.json' num_data = 7000 batch_size = 1 steps_per_epoch = np.ceil(num_data / batch_size) train_annot, val_annot = bu.annotate_tiny(val_json, labels_path, bdd100k_val_path, overwrite=True) cl_map_path = bu.class_mapping(input_json=val_json, output_csv=labels_path + 'class_mapping.csv') for m in models: print('Generating %s backbone...' % m) backbone = kr_models.backbone(m) weights = backbone.download_imagenet() print('Creating generators...') tr_gen, val_gen = bu.create_generators( train_annotations=train_annot, val_annotations=val_annot, class_mapping=cl_map_path, base_dir='', preprocess_image=backbone.preprocess_image, batch_size=batch_size) print('Creating models...') model, training_model, prediction_model = kr_train.create_models( backbone.retinanet, tr_gen.num_classes(), weights) print('Creating callbacks...') callbacks = bu.create_callbacks(model, batch_size, snapshots_path=retinanet_h5_path, tensorboard_dir=log_path, backbone=m, dataset_type='bdd10k') print('Training...') training_model.fit_generator( generator=tr_gen, steps_per_epoch=steps_per_epoch, # 10000, epochs=50, verbose=1, callbacks=callbacks, workers=1, # 1 use_multiprocessing=False, # False, max_queue_size=10, validation_data=val_gen)
def _initilize_model(num_classes): """Initilze our model to train with """ # Suggested to initialize model on cpu before turning into a # multi_gpu model to save gpu memory with tf.device('/cpu:0'): model = models.backbone('resnet50').retinanet(num_classes=num_classes) model.load_weights(config.WEIGHTS_PATH, by_name=True, skip_mismatch=True) gpus = len([i for i in device_lib.list_local_devices() if i.device_type == 'GPU']) if gpus > 1: return model, multi_gpu_model(model, gpus=gpus) return model, model
def __init__(self, weights=None, saved_model=None): self.weights = weights self.saved_model = saved_model # Read config file - if a config file exists in local dir use it, # if not use installed. if os.path.exists("deepforest_config.yml"): config_path = "deepforest_config.yml" else: try: config_path = get_data("deepforest_config.yml") except Exception as e: raise ValueError( "No deepforest_config.yml found either in local " "directory or in installed package location. {}".format(e)) print("Reading config file: {}".format(config_path)) self.config = utilities.read_config(config_path) # Create a label dict, defaults to "Tree" self.read_classes() # release version id to flag if release is being used self.__release_version__ = None # Load saved model if needed if self.saved_model: print("Loading saved model") # Capture user warning, not relevant here with warnings.catch_warnings(): warnings.filterwarnings("ignore", category=UserWarning) self.model = models.load_model(saved_model) self.prediction_model = convert_model(self.model) elif self.weights: print("Creating model from weights") backbone = models.backbone(self.config["backbone"]) self.model, self.training_model, self.prediction_model = create_models( backbone.retinanet, num_classes=1, weights=self.weights) else: print( "A blank deepforest object created. " "To perform prediction, either train or load an existing model." ) self.model = None
def run(args=None): args = parse_args(args) backbone = models.backbone(args.backbone) if args.config: args.config = read_config_file(args.config) _, generator = create_generators(args, backbone.preprocess_image) weights = os.path.join(args.snapshot_path, 'checkpoint.h5') _, _, model = create_models( backbone_retinanet=backbone.retinanet, num_classes=10, weights=weights, multi_gpu=args.multi_gpu, freeze_backbone=args.freeze_backbone, lr=args.lr, config=args.config ) infer(generator, model)
def test_equivalence(config, setup_create_tensors): # unpack created tensors tf_inputs, tf_targets = setup_create_tensors # the image going in to tensorflow should be equivalent # to the image from the fit_generator backbone = models.backbone(config["backbone"]) # CSV generator generator = csv_generator.CSVGenerator( csv_data_file="tests/output/testfile_tfrecords.csv", csv_class_file="tests/data/classes.csv", image_min_side=config["image-min-side"], preprocess_image=backbone.preprocess_image, ) # find file in randomize generator group first_file = generator.groups[0][0] gen_filename = os.path.join(generator.base_dir, generator.image_names[first_file]) original_image = generator.load_image(first_file) inputs, targets = generator.__getitem__(0) image = inputs[0, ...] targets = targets[0][0, ...] with tf.Session() as sess: # seek the randomized image to match tf_inputs, tf_targets = sess.run([tf_inputs, tf_targets]) # assert filename is the same as generator # assert gen_filename == filename # tf_image = tf_image[0,...] tf_inputs = tf_inputs[0, ...] tf_targets = tf_targets[0][0, ...] # Same shape # assert tf_image.shape == image.shape assert tf_inputs.shape == image.shape assert tf_targets.shape == targets.shape
def test_multigpu_training(): experiment = Experiment(api_key="ypQZhYfs3nSyKzOfz13iuJpj2", project_name='deeplidar', log_code=True) DeepForest_config = config.load_config(dir="..") DeepForest_config["save_image_path"] = "../snapshots/" data = generators.load_retraining_data(DeepForest_config) train_generator, validation_generator = generators.create_h5_generators( data, DeepForest_config=DeepForest_config) #imagenet pretraining weights backbone = models.backbone(DeepForest_config["backbone"]) weights = backbone.download_imagenet() model, training_model, prediction_model = create_models( backbone_retinanet=backbone.retinanet, num_classes=train_generator.num_classes(), weights=weights, multi_gpu=DeepForest_config["num_GPUs"], freeze_backbone=False, nms_threshold=DeepForest_config["nms_threshold"], input_channels=DeepForest_config["input_channels"]) #start training history = training_model.fit_generator( generator=train_generator, steps_per_epoch=train_generator.size() / DeepForest_config["batch_size"], epochs=DeepForest_config["epochs"], verbose=2, shuffle=False, workers=DeepForest_config["workers"], use_multiprocessing=DeepForest_config["use_multiprocessing"], max_queue_size=DeepForest_config["max_queue_size"], experiment=experiment)
evaluation = True # Хэрэв сургалтаа үргэлжлүүлэх бол snapshot-ын утганд сүүлийн сургалтын файлыг зааж өгнө snapshot = './snapshots/resnet50_csv_03.h5' # Snapshot хадгалах эсэх, хадгалах хавтас snapshots = True snapshot_path = './snapshots' tensorboard_dir = './logs' weights = None imagenet_weights = True batch_size = 1 image_min_side = 225 image_max_side = 300 backbone_model = models.backbone('resnet50') freeze_backbone = False common_args = { 'batch_size': batch_size, 'image_min_side': image_min_side, 'image_max_side': image_max_side, 'preprocess_image': backbone_model.preprocess_image, } train_generator = CSVGenerator(annotations_path, classes_path, **common_args) if validations_path != '': validation_generator = CSVGenerator(validations_path, classes_path, **common_args) else: validation_generator = None
def main(args=None): # parse arguments if args is None: args = sys.argv[1:] args = parse_args(args) # create object that stores backbone information backbone = models.backbone(args.backbone) # make sure keras is the minimum required version check_keras_version() # optionally choose specific GPU if args.gpu: os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu keras.backend.set_session(get_session()) # optionally load config parameters if args.config: args.config = read_config_file(args.config) # create the generators train_generator, validation_generator = create_generators( args, backbone.preprocess_image) # create the model if args.snapshot is not None: print('Loading model, this may take a second...') model = models.load_model(args.snapshot, backbone_name=args.backbone) training_model = model anchor_params = None if args.config and 'anchor_parameters' in args.config: anchor_params = parse_anchor_parameters(args.config) prediction_model = retinanet_bbox(model=model, anchor_params=anchor_params) else: weights = args.weights # default to imagenet if nothing else is specified if weights is None and args.imagenet_weights: weights = backbone.download_imagenet() print('Creating model, this may take a second...') model, training_model, prediction_model = create_models( backbone_retinanet=backbone.retinanet, num_classes=train_generator.num_classes(), weights=weights, multi_gpu=args.multi_gpu, freeze_backbone=args.freeze_backbone, lr=args.lr, config=args.config) # print model summary print(model.summary()) # this lets the generator compute backbone layer shapes using the actual backbone model # if 'vgg' in args.backbone or 'densenet' in args.backbone: # train_generator.compute_shapes = make_shapes_callback(model) # if validation_generator: # validation_generator.compute_shapes = train_generator.compute_shapes # create the callbacks callbacks = create_callbacks(model, training_model, prediction_model, validation_generator, args, eval_batch_size=args.val_batch_size) # Use multiprocessing if workers > 0 if args.workers > 0: use_multiprocessing = True else: use_multiprocessing = False # start training training_model.fit_generator(generator=train_generator, steps_per_epoch=args.steps, epochs=args.epochs, verbose=1, callbacks=callbacks, workers=args.workers, use_multiprocessing=use_multiprocessing, max_queue_size=args.max_queue_size)
def test_equivalence(config, setup_create_tensors): #unpack created tensors tf_inputs, tf_targets = setup_create_tensors #the image going in to tensorflow should be equivalent to the image from the fit_generator backbone = models.backbone(config["backbone"]) #CSV generator generator = csv_generator.CSVGenerator( csv_data_file="tests/data/testfile_tfrecords.csv", csv_class_file="tests/data/classes.csv", image_min_side=config["image-min-side"], preprocess_image=backbone.preprocess_image, ) #find file in randomize generator group first_file = generator.groups[0][0] gen_filename = os.path.join(generator.base_dir, generator.image_names[first_file]) original_image = generator.load_image(first_file) inputs, targets = generator.__getitem__(0) image = inputs[0,...] targets = targets[0][0,...] with tf.Session() as sess: #seek the randomized image to match tf_inputs, tf_targets = sess.run([tf_inputs,tf_targets]) #assert filename is the same as generator #assert gen_filename == filename #tf_image = tf_image[0,...] tf_inputs = tf_inputs[0,...] tf_targets = tf_targets[0][0,...] #Same shape #assert tf_image.shape == image.shape assert tf_inputs.shape == image.shape assert tf_targets.shape == targets.shape #Same values, slightly duplicitious with above, but useful for debugging. #Saved array is the same as generator image #np.testing.assert_array_equal(image, tf_image) #Loaded array is the same as generator, this is not true currently, the opencv and the tensorflow interpolation method is slightly different, waiting for tf. 2.0 #np.testing.assert_array_equal(tf_loaded, tf_image) ##Useful for debug to plot #fig = plt.figure() #ax1 = fig.add_subplot(1,4,1) #ax1.title.set_text('Fit Gen Original') #plt.imshow(original_image[...,::-1]) #ax1 = fig.add_subplot(1,4,2) #ax1.title.set_text('Fit Generator') #plt.imshow(image) #ax2 = fig.add_subplot(1,4,3) #ax2 = fig.add_subplot(1,4,4) #ax2.title.set_text('Loaded Image') #plt.imshow(tf_inputs) #plt.show() #Check for bad file types #@pytest.fixture() #def bad_annotations(): #annotations = utilities.xml_to_annotations(get_data("OSBS_029.xml")) #f = "tests/data/testfile_error_deepforest.csv" #annotations.to_csv(f,index=False,header=False) #return f #def test_tfdataset_error(bad_annotations): #with pytest.raises(ValueError): #records_created = tfrecords.create_tfrecords(annotations_file=bad_annotations, class_file=get_data("classes.csv"), image_min_side=800, backbone_model="resnet50", size=100, savedir="tests/data/")
'regression': losses.smooth_l1(), 'classification': losses.focal() }, optimizer=keras.optimizers.adam(lr=lr, clipnorm=0.001)) return model, training_model, prediction_model if __name__ == '__main__': smin, smax = 618, 800 keras.backend.tensorflow_backend.set_session(get_session()) model_path = os.path.join('snapshots', '7', 'resnet18_csv_19.h5') backbone = models.backbone('resnet18') labels_to_names = { 0: 'goodhelmet', 1: 'LP', 2: 'goodshoes', 3: 'badshoes', 4: 'badhelmet', 5: 'person' } # labels_to_names = {0: 'person', 1: 'helmet', 2: 'LP', 3: 'goodshoes', 4: 'badshoes'} # labels_to_names = {0: 'person', 1: 'LP', 2: 'badshoes', 3: 'unsafe_hat', 4: 'Boot', 5: 'helmet', # 6: 'goodshoes'} main_model, training_model, prediction_model = create_models( backbone.retinanet, len(labels_to_names)) main_model.load_weights(model_path)
def main(args=None): global config from keras import backend as K # parse arguments if args is None: args = sys.argv[1:] args = parse_args(args) print('Arguments: {}'.format(args)) # create object that stores backbone information backbone = models.backbone(args.backbone) # make sure keras is the minimum required version check_keras_version() # optionally choose specific GPU if args.gpu: os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu keras.backend.tensorflow_backend.set_session(get_session()) # create the generators train_generator, validation_generator = create_generators( args, backbone.preprocess_image) # create the model if args.snapshot is not None: print('Loading model, this may take a second...') model = models.load_model(args.snapshot, backbone_name=args.backbone) training_model = model anchor_params = None if 'anchor_parameters' in config: anchor_params = parse_anchor_parameters(config) prediction_model = retinanet_bbox(model=model, anchor_params=anchor_params) else: weights = args.weights # default to imagenet if nothing else is specified if weights is None and args.imagenet_weights: weights = backbone.download_imagenet() print('Creating model, this may take a second...') model, training_model, prediction_model = create_models( backbone_retinanet=backbone.retinanet, num_classes=train_generator.num_classes(), weights=weights, args=args, multi_gpu=args.multi_gpu, freeze_backbone=args.freeze_backbone, config=config) # print model summary print(model.summary()) print('Learning rate: {}'.format(K.get_value(model.optimizer.lr))) if args.lr > 0.0: K.set_value(model.optimizer.lr, args.lr) print('Updated learning rate: {}'.format( K.get_value(model.optimizer.lr))) # this lets the generator compute backbone layer shapes using the actual backbone model if 'vgg' in args.backbone or 'densenet' in args.backbone: train_generator.compute_shapes = make_shapes_callback(model) if validation_generator: validation_generator.compute_shapes = train_generator.compute_shapes # create the callbacks callbacks = create_callbacks( model, training_model, prediction_model, validation_generator, args, ) init_epoch = 0 try: if args.snapshot: init_epoch = int(args.snapshot.split("_")[-2]) except: pass # init_epoch = 6 print('Init epoch: {}'.format(init_epoch)) # start training training_model.fit_generator( generator=train_generator, steps_per_epoch=args.steps, epochs=args.epochs, verbose=1, callbacks=callbacks, initial_epoch=init_epoch, )
def main(args=None): # parse arguments if args is None: args = sys.argv[1:] args = parse_args(args) # create object that stores backbone information backbone = models.backbone(args.backbone) # make sure keras is the minimum required version check_keras_version() # optionally choose specific GPU if args.gpu: os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu keras.backend.tensorflow_backend.set_session(get_session()) # create the generators train_generator, validation_generator = create_generators( args, backbone.preprocess_image) # create the model if args.snapshot is not None: print('Loading model, this may take a second...') model = models.load_model(args.snapshot, backbone_name=args.backbone) training_model = model prediction_model = retinanet_bbox(model=model) else: weights = args.weights # default to imagenet if nothing else is specified if weights is None and args.imagenet_weights: weights = backbone.download_imagenet() else: print("Don't load weight!") print('Creating model, this may take a second...') model, training_model, prediction_model = create_models( backbone_retinanet=backbone.retinanet, num_classes=train_generator.num_classes(), weights=weights, multi_gpu=args.multi_gpu, freeze_backbone=args.freeze_backbone) # print model summary print(model.summary()) # create the callbacks callbacks = create_callbacks( model, training_model, prediction_model, validation_generator, args, ) # start training training_model.fit_generator(generator=train_generator, steps_per_epoch=args.steps, epochs=args.epochs, verbose=1, callbacks=callbacks, validation_data=validation_generator, validation_steps=20)
def main(args=None, data=None, DeepForest_config=None, experiment=None): # parse arguments if args is None: args = sys.argv[1:] args = parse_args(args) # create object that stores backbone information backbone = models.backbone(args.backbone) # make sure keras is the minimum required version check_keras_version() # optionally choose specific GPU if args.gpu: os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu keras.backend.tensorflow_backend.set_session(get_session()) # create the generators train_generator, validation_generator = create_generators( args, data, DeepForest_config=DeepForest_config) # create the model if args.snapshot is not None: print('Loading model, this may take a secondkeras-retinanet.\n') model = models.load_model(args.snapshot, backbone_name=args.backbone) training_model = model prediction_model = retinanet_bbox( model=model, nms_threshold=DeepForest_config["nms_threshold"]) else: weights = args.weights # default to imagenet if nothing else is specified if weights is None and args.imagenet_weights: weights = backbone.download_imagenet() print('Creating model, this may take a secondkeras-retinanet .') model, training_model, prediction_model = create_models( backbone_retinanet=backbone.retinanet, num_classes=train_generator.num_classes(), weights=weights, multi_gpu=args.multi_gpu, freeze_backbone=args.freeze_backbone, nms_threshold=DeepForest_config["nms_threshold"]) # print model summary #print(model.summary()) # this lets the generator compute backbone layer shapes using the actual backbone model if 'vgg' in args.backbone or 'densenet' in args.backbone: compute_anchor_targets = functools.partial( anchor_targets_bbox, shapes_callback=make_shapes_callback(model)) train_generator.compute_anchor_targets = compute_anchor_targets if validation_generator is not None: validation_generator.compute_anchor_targets = compute_anchor_targets matched = [] for entry in validation_generator.image_data.values(): test = entry in train_generator.image_data.values() matched.append(test) if sum(matched) > 0: raise Exception( "%.2f percent of validation windows are in training data" % (100 * sum(matched) / train_generator.size())) else: print("Test passed: No overlapping data in training and validation") #start training cp.enable() training_model.fit_generator(generator=train_generator, steps_per_epoch=train_generator.size() / DeepForest_config["batch_size"], epochs=args.epochs, verbose=1, shuffle=False, callbacks=None, workers=DeepForest_config["workers"], use_multiprocessing=True) cp.disable()
'classification': losses.focal() }, optimizer=keras.optimizers.adam(lr=lr, clipnorm=0.001)) return model, training_model, prediction_model if __name__ == '__main__': smin, smax = 1200, 1600 keras.backend.tensorflow_backend.set_session(get_session()) model_path = os.path.join('snapshots', '5', 'resnet50_csv_05.h5') backbone = models.backbone('resnet50') labels_to_names = {1: 'mif', 0: 'ov'} main_model, training_model, prediction_model = create_models( backbone.retinanet, len(labels_to_names)) main_model.load_weights(model_path) model = prediction_model path = '/media/palm/data/MicroAlgae/images' pad = 0 ls = [ s.split(',')[0] for s in open('datastuff/algea/val_annotations').read().split('\n') ] found = [] # while True: # p = os.path.join(path, np.random.choice(os.listdir(path)))
def load_pb_model(pb_model_path): start = time.time() pb_model = keras.models.load_model(pb_model_path, custom_objects=models.backbone('resnet50').custom_objects) print("Load .pb model - processing time: ", time.time() - start) return pb_model
def main(args=None): # parse arguments if args is None: args = sys.argv[1:] args = parse_args(args) # create object that stores backbone information backbone = models.backbone(args.backbone) # make sure keras is the minimum required version check_keras_version() # optionally choose specific GPU if args.gpu: os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu keras.backend.tensorflow_backend.set_session(get_session()) # create the generators train_generator, validation_generator = create_generators(args, backbone.preprocess_image) # create the model if args.snapshot is not None: print('Loading model, this may take a second...') model = models.load_model(args.snapshot, backbone_name=args.backbone) training_model = model prediction_model = retinanet_bbox(model=model) else: weights = args.weights # default to imagenet if nothing else is specified if weights is None and args.imagenet_weights: weights = backbone.download_imagenet() print('Creating model, this may take a second...') model, training_model, prediction_model = create_models( backbone_retinanet=backbone.retinanet, num_classes=train_generator.num_classes(), weights=weights, multi_gpu=args.multi_gpu, freeze_backbone=args.freeze_backbone ) # print model summary print(model.summary()) # this lets the generator compute backbone layer shapes using the actual backbone model if 'vgg' in args.backbone or 'densenet' in args.backbone: train_generator.compute_shapes = make_shapes_callback(model) if validation_generator: validation_generator.compute_shapes = train_generator.compute_shapes # create the callbacks callbacks = create_callbacks( model, training_model, prediction_model, validation_generator, args, ) # start training history=training_model.fit_generator( generator=train_generator, steps_per_epoch=args.steps, epochs=args.epochs, verbose=1, callbacks=callbacks, ) timestr=time.strftime("%Y-%m-%d-%H%M") history_path=os.path.join( args.snapshot_path, '{timestr}_{backbone}.csv'.format(timestr=timestr,backbone=args.backbone, dataset_type=args.dataset_type) ) pd.DataFrame(history.history).to_csv(history_path)