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 train(self,
annotation_path,
class_path,
snapshot_src=None,
tensorboard_dir=None,
snapshot_dir=None,
snapshot_tag=None,
snapshot_freq=10):
""" Train routine.
Params:
annotation_path: file path for target annotations
class_path: file path for class-id mapping
snapshot_src: file path of snapshot to continue training
tensorboard_dir: directory for saving tensorboard
snapshot_dir: directory for saving snapshots
shapshot_tag: tag used as filename identifier for snapshots
shapshot_freq: epoch interval for saving snapshots
"""
if self._epoch % snapshot_freq != 0:
print(
"Error: Snapshot saving interval should be set to factor of total epochns ({})."
.format(self._epoch))
return
# Load network backbone
generator = self.__create_generator(annotation_path, class_path)
if snapshot_src:
model = models.load_model(snapshot_src,
backbone_name=self._backbone_name)
training_model = model
prediction_model = retinanet_bbox(
model=model, anchor_params=self._anchor_params)
else:
model, training_model, prediction_model = self.__create_models(
self._backbone.retinanet, generator.num_classes())
print(model.summary())
if 'vgg' in self._backbone_name or 'densenet' in self._backbone_name:
generator.compute_shapes = make_shapes_callback(model)
callbacks = self.__create_callbacks(model, training_model,
prediction_model, tensorboard_dir,
snapshot_dir, snapshot_tag,
snapshot_freq)
training_model.fit_generator(generator=generator,
steps_per_epoch=self._step,
epochs=self._epoch,
verbose=1,
callbacks=callbacks)
def main(args=None):
# parse arguments
if args is None:
args = sys.argv[1:]
args = parse_args(args)
# 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())
# optionally load config parameters
if args.config:
args.config = read_config_file(args.config)
# create the generators
generator = create_generators(args)
# create the model
print('Loading model, this may take a second...')
model = models.load_model(args.snapshot, backbone_name=args.backbone)
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)
# print model summary
prediction_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:
generator.compute_shapes = make_shapes_callback(model)
# inference
boxes, scores, labels = prediction_model.predict_generator(
generator=generator,
verbose=1,
)
# generate COCO annotations
create_coco_annotations(boxes, scores, labels, generator.image_ids)
prediction_model = retinanet_bbox(model=model)
# compile model
training_model.compile(loss={
'regression': losses.smooth_l1(),
'classification': losses.focal()
},
optimizer=keras.optimizers.adam(lr=1e-5,
clipnorm=0.001))
# print model summary
print(model.summary())
# this lets the generator compute backbone layer shapes using the actual backbone model
if 'vgg' in backbone or 'densenet' in backbone:
train_generator.compute_shapes = make_shapes_callback(model)
if validation_generator:
validation_generator.compute_shapes = train_generator.compute_shapes
callbacks = []
tensorboard_callback = None
if tensorboard_dir:
tensorboard_callback = keras.callbacks.TensorBoard(
log_dir=tensorboard_dir,
histogram_freq=0,
batch_size=batch_size,
write_graph=True,
write_grads=False,
write_images=False,
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, 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()
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)
def main(forest_object,
args=None,
input_type="fit_generator",
list_of_tfrecords=None,
comet_experiment=None):
"""
Main Training Loop
Args:
forest_object: a deepforest class object
args: Keras retinanet argparse
list_of_tfrecords: list of tfrecords to parse
input_type: "fit_generator" or "tfrecord" input type
"""
# 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:
setup_gpu(args.gpu)
# optionally load config parameters
if args.config:
args.config = read_config_file(args.config)
# data input
if input_type == "fit_generator":
# create the generators
train_generator, validation_generator = create_generators(
args, backbone.preprocess_image)
# placeholder target tensor for creating models
targets = None
elif input_type == "tfrecord":
# Create tensorflow iterators
iterator = tfrecords.create_dataset(list_of_tfrecords, args.batch_size)
next_element = iterator.get_next()
# Split into inputs and targets
inputs = next_element[0]
targets = [next_element[1], next_element[2]]
validation_generator = None
else:
raise ValueError(
"{} input type is invalid. Only 'tfrecord' or 'for_generator' "
"input types are accepted for model training".format(input_type))
# 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...')
if input_type == "fit_generator":
num_of_classes = train_generator.num_classes()
else:
# Add background class
num_of_classes = len(forest_object.labels.keys())
model, training_model, prediction_model = create_models(
backbone_retinanet=backbone.retinanet,
num_classes=num_of_classes,
weights=weights,
multi_gpu=args.multi_gpu,
freeze_backbone=args.freeze_backbone,
lr=args.lr,
config=args.config,
targets=targets,
freeze_layers=args.freeze_layers)
# 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, comet_experiment)
if not args.compute_val_loss:
validation_generator = None
# start training
if input_type == "fit_generator":
history = training_model.fit_generator(
generator=train_generator,
steps_per_epoch=args.steps,
epochs=args.epochs,
verbose=1,
callbacks=callbacks,
workers=args.workers,
use_multiprocessing=args.multiprocessing,
max_queue_size=args.max_queue_size,
validation_data=validation_generator)
elif input_type == "tfrecord":
# Fit model
history = training_model.fit(x=inputs,
steps_per_epoch=args.steps,
epochs=args.epochs,
callbacks=callbacks)
else:
raise ValueError(
"{} input type is invalid. Only 'tfrecord' or 'for_generator' "
"input types are accepted for model training".format(input_type))
# Assign history to deepforest model class
forest_object.history = history
# return trained model
return model, prediction_model, training_model
def main(args=None):
# parse arguments
if args is None:
args = sys.argv[1:]
args = parse_args(args)
# Export configs
configs = {
'backbone': args.backbone,
'min_size': args.image_min_side,
'max_size': args.image_max_side
}
conf_path = os.path.join(args.export_path, 'configs.json')
with open(conf_path, 'wt') as f:
json.dump(configs, f)
# 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())
# 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,
)
# 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 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 and tensorflow are the minimum required version
check_keras_version()
check_tf_version()
# optionally choose specific GPU
if args.gpu is not None:
setup_gpu(args.gpu)
# 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,
regularisation=args.regularisation
)
# 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,
)
if not args.compute_val_loss:
validation_generator = None
# start training
return training_model.fit_generator(
generator=train_generator,
steps_per_epoch=args.steps,
epochs=args.epochs,
verbose=1,
callbacks=callbacks,
workers=args.workers,
use_multiprocessing=args.multiprocessing,
max_queue_size=args.max_queue_size,
validation_data=validation_generator,
initial_epoch=args.initial_epoch
)
def main(args=None):
log_util.config(__file__)
logger = logging.getLogger(__name__)
# parse arguments
if args is None:
args = sys.argv[1:]
args = parse_args(args)
# 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)
if 'resnet' in args.backbone:
from keras_retinanet.models.resnet import resnet_retinanet as retinanet, custom_objects, download_imagenet
elif 'mobilenet' in args.backbone:
from keras_retinanet.models.mobilenet import mobilenet_retinanet as retinanet, custom_objects, download_imagenet
elif 'vgg' in args.backbone:
from keras_retinanet.models.vgg import vgg_retinanet as retinanet, custom_objects, download_imagenet
elif 'densenet' in args.backbone:
from keras_retinanet.models.densenet import densenet_retinanet as retinanet, custom_objects, download_imagenet
else:
raise NotImplementedError('Backbone \'{}\' not implemented.'.format(
args.backbone))
# create the model
if args.snapshot is not None:
logger.info('Loading model, this may take a second...')
model = keras.models.load_model(args.snapshot,
custom_objects=custom_objects)
training_model = model
prediction_model = model
else:
weights = args.weights
# default to imagenet if nothing else is specified
if weights is None and args.imagenet_weights:
weights = download_imagenet(args.backbone)
logger.info('Creating model, this may take a second...')
model, training_model, prediction_model = create_models(
backbone_retinanet=retinanet,
backbone=args.backbone,
num_classes=train_generator.num_classes(),
weights=weights,
multi_gpu=args.multi_gpu,
freeze_backbone=args.freeze_backbone)
logger.info(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
# 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,
workers=4)
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())
if args.anchors:
anchors_dict = get_anchors_params(args.anchors)
elif args.snapshot:
#search the anchors parameters configure beside models
anchors_path = os.path.join(args.snapshot,"anchors.yaml")
anchors_path = anchors_path if os.path.exists(anchors_path) else None
anchors_dict = get_anchors_params(anchors_path)
else:
#default anchors params
anchors_dict = get_anchors_params(None)
anchors_params = AnchorParameters(**anchors_dict)
if args.snapshots and args.anchors:
#save anchors configure beside models
makedirs(args.snapshot_path)
anchors_out = os.path.join(
args.snapshot_path,
"anchors.yaml"
)
save_anchors_params(anchors_dict,anchors_out)
# 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,anchor_parameters = anchors_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,
anchors_path=args.anchors
)
# 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
training_model.fit_generator(
generator=train_generator,
steps_per_epoch=args.steps,
epochs=args.epochs,
verbose=1,
callbacks=callbacks,
)
def main(args=None, data=None, DeepForest_config=None, experiment=None):
# parse arguments
print("parsing 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
print("Get keras version")
check_keras_version()
# optionally choose specific GPU
if args.gpu:
os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu
print("Get session")
keras.backend.tensorflow_backend.set_session(get_session())
# create the generators
print("Creating generators")
train_generator, validation_generator = create_generators(args, data, DeepForest_config=DeepForest_config)
#Log number of trees trained on
if experiment:
experiment.log_parameter("Number of Training Trees", train_generator.total_trees)
# 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:
print("Loading 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"],
input_channels=DeepForest_config["input_channels"]
)
# 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
# create the callbacks
callbacks = create_callbacks(
model,
training_model,
prediction_model,
train_generator,
validation_generator,
args,
experiment,
DeepForest_config
)
#Make sure no overlapping data
if validation_generator:
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
history = training_model.fit_generator(
generator=train_generator,
steps_per_epoch=train_generator.size()/DeepForest_config["batch_size"],
epochs=args.epochs,
verbose=2,
shuffle=False,
callbacks=callbacks,
workers=DeepForest_config["workers"],
use_multiprocessing=DeepForest_config["use_multiprocessing"],
max_queue_size=DeepForest_config["max_queue_size"]
)
#return path snapshot of final epoch
saved_models = glob.glob(os.path.join(args.snapshot_path,"*.h5"))
saved_models.sort()
#Return model if found
if len(saved_models) > 0:
return saved_models[-1]
def main(args=None, config=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, config)
# create the model
if args.snapshot is not None:
print('Loading model, this may take a secondkeras-retinanet .')
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 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)
# 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
# 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,
)
def main(args=None, model_filename=None):
# parse arguments
if args is None:
args = sys.argv[1:]
args = parse_args(args)
# make sure keras and tensorflow are the minimum required version
check_keras_version()
check_tf_version()
# optionally choose specific GPU
if args.gpu:
setup_gpu(args.gpu)
# make save path if it doesn't exist
if args.save_path is not None and not os.path.exists(args.save_path):
os.makedirs(args.save_path)
# optionally load config parameters
if args.config:
args.config = read_config_file(args.config)
# create the generator
backbone = models.backbone(args.backbone)
generator = create_generator(args, backbone.preprocess_image)
# optionally load anchor parameters
anchor_params = None
if args.config and 'anchor_parameters' in args.config:
anchor_params = parse_anchor_parameters(args.config)
# load the model
print('Loading model, this may take a second...')
if args.continual_learning_model == 'dual_memory': # Continual learning dual-memory modelling treatment
base_models = LoadModels(args.historical_snapshots_folder,
args.backbone, args.day_number)
all_models = []
for model in base_models:
generator.compute_shapes = make_shapes_callback(model)
if args.convert_model:
model = models.convert_model(model,
anchor_params=anchor_params)
all_models.append(model)
(average_precisions, inference_time, detections_per_model,
final_detections) = evaluate_dual_memory_model(
generator,
all_models,
iou_threshold=args.iou_threshold,
score_threshold=args.score_threshold,
max_detections=args.max_detections,
save_path=args.save_path)
# bbox_savepath given, save bounding box coordinates from dual-memory model predictions:
if args.bbox_savepath:
detections_per_model = [[
[class_predictions.tolist() for class_predictions in image]
for image in model_predictions
] for model_predictions in detections_per_model]
detections_with_filenames = {
'final_detections': final_detections,
'annotations': args.annotations,
'detections_per_model': detections_per_model
}
with open(args.bbox_savepath, 'wt') as outf:
json.dump(detections_with_filenames, outf)
print("Finished dual memory model")
print(average_precisions, inference_time)
else:
if model_filename is None:
model_filename = args.model
model = models.load_model(model_filename, backbone_name=args.backbone)
generator.compute_shapes = make_shapes_callback(model)
# optionally convert the model
if args.convert_model:
model = models.convert_model(model, anchor_params=anchor_params)
# print model summary
# print(model.summary())
# start evaluation
if args.dataset_type == 'coco':
from ..utils.coco_eval import evaluate_coco
evaluate_coco(generator, model, args.score_threshold)
else:
average_precisions, inference_time = evaluate(
generator,
model,
iou_threshold=args.iou_threshold,
score_threshold=args.score_threshold,
max_detections=args.max_detections,
save_path=args.save_path)
# print evaluation
total_instances = []
precisions = []
#labels = []
for label, (average_precision,
num_annotations) in average_precisions.items():
print('{:.0f} instances of class'.format(num_annotations),
generator.label_to_name(label),
'with average precision: {:.4f}'.format(average_precision))
#labels.append(label)
total_instances.append(num_annotations)
precisions.append(average_precision)
if sum(total_instances) == 0:
print('No test instances found.')
return
print('Inference time for {:.0f} images: {:.4f}'.format(
generator.size(), inference_time))
print('mAP using the weighted average of precisions among classes: {:.4f}'.
format(
sum([a * b for a, b in zip(total_instances, precisions)]) /
sum(total_instances)))
print('mAP: {:.4f}'.format(
sum(precisions) / sum(x > 0 for x in total_instances)))
#print(labels)
print(precisions)
print(total_instances)
# Save mAP and other accuracy statistics to mAP_savepath:
mAP = sum(precisions) / sum(x > 0 for x in total_instances)
date = datetime.now().strftime("%Y%m%d%H%M")
with open(args.mAP_savepath, 'a') as outf:
outf.write(
f"{date}, {mAP}, {precisions}, {total_instances}, {model_filename}, {args.continual_learning_model}"
+ "\n")
return mAP
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 = get_backbone(args.backbone)
# make sure keras is the minimum required version
check_keras_version()
if args.dataset_type == 'run':
model = load_model(args.model_path,
backbone_name=args.backbone,
convert=True)
labels_to_names = {0: 'cell'}
makedirs(args.save_path)
test_imlist = next(os.walk(args.run_path))[2]
for testimgcnt, img_path in enumerate(test_imlist):
image = get_image(img_path)
draw2 = get_image(img_path)
draw2 = draw2 / np.max(draw2)
# copy to draw on
# preprocess image for network
image = preprocess_image(image)
image, scale = resize_image(image)
print(scale)
# process image
start = time.time()
boxes, scores, labels = model.predict_on_batch(
np.expand_dims(image, axis=0))
print('processing time: ', time.time() - start)
# correct for image scale
boxes /= scale
# visualize detections
for box, score, label in zip(boxes[0], scores[0], labels[0]):
# scores are sorted so we can break
if score < 0.5:
break
color = label_color(label)
color = [255, 0, 255]
b = box.astype(int)
draw_box(draw2, b, color=color)
caption = '{} {:.3f}'.format(labels_to_names[label], score)
draw_caption(draw2, b, caption)
plt.imsave(
os.path.join(args.save_path,
'retinanet_output_' + str(testimgcnt)), draw2)
# 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 = 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())
# this lets the generator compute backbone layer shapes using the actual backbone model
if any(x in args.backbone for x in ['vgg', 'densenet', 'deepcell']):
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
training_model.fit_generator(
generator=train_generator,
steps_per_epoch=args.steps,
epochs=args.epochs,
verbose=1,
callbacks=callbacks,
)
