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 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 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 __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 return_objects(model_path, class_path, image_path, iou_threshold=0.25, model='resnet152'):
with open(class_path, 'r') as f:
classes = [x.strip() for x in f.readlines()]
labels_to_names={}
for i, c in enumerate(classes):
labels_to_names[i] = c
# ## Load RetinaNet model
if 'resnet' in model_path:
from keras_retinanet.models.resnet import resnet_retinanet as retinanet, custom_objects, download_imagenet
elif 'mobilenet' in model_path:
from keras_retinanet.models.mobilenet import mobilenet_retinanet as retinanet, custom_objects, download_imagenet
elif 'vgg' in model_path:
from keras_retinanet.models.vgg import vgg_retinanet as retinanet, custom_objects, download_imagenet
elif 'densenet' in model_path:
from keras_retinanet.models.densenet import densenet_retinanet as retinanet, custom_objects, download_imagenet
else:
raise NotImplementedError('Backbone \'{}\' not implemented.'.format(model_path))
_, _, model = create_models(
backbone_retinanet=retinanet,
backbone=model,
num_classes=len(classes),
weights=model_path,
multi_gpu=False,
freeze_backbone=False
)
image = read_image_bgr(image_path)
# preprocess image for network
image = preprocess_image(image)
image, scale = resize_image(image)
# process image
start = time.time()
_, _, boxes, nms_classification = model.predict_on_batch(np.expand_dims(image, axis=0))
#print("processing time: ", time.time() - start)
# compute predicted labels and scores
predicted_labels = np.argmax(nms_classification[0, :, :], axis=1)
scores = nms_classification[0, np.arange(nms_classification.shape[1]), predicted_labels]
# correct for image scale
boxes /= scale
plabels, pscores, pboxes = [], [], []
for idx, (label, score) in enumerate(zip(predicted_labels, scores)):
if score<0.5:
continue
pboxes.append(boxes[0, idx, :].astype(int))
plabels.append([label])
pscores.append(score)
rboxes, rscores, rlabels, ignore, inter = [], [], [], [], False
for i in range(len(pboxes)):
if i in ignore:
continue
for j in range(i+1, len(pboxes)):
if intersects(pboxes[i], pboxes[j]):
iou = area(pboxes[i], pboxes[j])/float(union(pboxes[i], pboxes[j])-area(pboxes[i], pboxes[j]))
if pscores[i]<pscores[j] and iou>iou_threshold:
inter = True
elif pscores[i]>pscores[j] and iou>iou_threshold:
ignore.append(j)
plabels[i].append(plabels[j][0])
if not inter:
rboxes.append(pboxes[i])
rscores.append(pscores[i])
rlabels.append(plabels[i])
else:
inter = False
return rlabels, rscores, rboxes, labels_to_names
factor=0.1,
patience=2,
verbose=1,
mode='auto',
epsilon=0.0001,
cooldown=0,
min_lr=0
))
callbacks.append(LossHistory())
callbacks.append(model_checkpoint)
callbacks.append(evaluation)
model, training_model, prediction_model = create_models(
backbone_retinanet=retinanet,
backbone='resnet50',
num_classes=train_generator.num_classes(),
weights=weights,
multi_gpu=0,
freeze_backbone=True
)
training_model.fit_generator(
generator=train_generator,
steps_per_epoch=5000,
epochs=100,
verbose=1,
callbacks=callbacks,
validation_data=validation_generator,
validation_steps=100
)
checkpoint = RedirectModel(checkpoint, model)
return [
lr_reduce,
early_stopping,
evaluation,
checkpoint,
]
BACKBONE = 'resnet50'
from pathlib import Path
for shape in SHAPES:
log_dir = Path('/home/paperspace/retinanet_shape_{}_{}/'.format(*shape))
log_dir.mkdir(exist_ok=True)
kw = dict(image_min_side=shape[0], image_max_side=shape[1], batch_size=4)
train_gen = CSVGenerator('train_path2.csv', class_map_path, **kw)
val_gen = CSVGenerator('val_path_small_2.csv', class_map_path, **kw)
model, training_model, prediction_model = create_models(
backbone_retinanet=models.backbone(BACKBONE).retinanet,
num_classes=train_gen.num_classes(),
weights=wt_50_path,
multi_gpu=0,
freeze_backbone=True,
config=None)
callbacks = make_callbacks(log_dir, model, prediction_model)
history = model.fit_generator(train_gen,
steps_per_epoch=10000 / 4,
epochs=40,
verbose=1,
callbacks=callbacks)
evaluation = True
snapshots = True
snapshot_path = "C:\\Users\\Pawan\\Documents\\ML\\snapshots12"
backbone = 'resnet50'
epochs = 100
steps = 10755//(batch_size)
gpu=0
resize=True
train_gen,valid_gen = create_generators(args,b.preprocess_image)
model, training_model, prediction_model = create_models(
backbone_retinanet=b.retinanet,
num_classes=train_gen.num_classes(),
weights=None,
multi_gpu=True,
freeze_backbone=True,
lr=1e-9,
config=args.config
)
training_model.load_weights("C:\\Users\\Pawan\\Documents\\ML\\snapshots12\\resnet50_csv_07.h5")
infer_model = convert_model(training_model,anchor_params=parse_anchor_parameters(read_config_file('C:\\Users\\Pawan\\Documents\\config.ini')))
def test_gen(image_ids, bs = 2, size=672,test = True):
imgs = []
scale = None
idx = 0
if test:
from keras_retinanet.models.resnet import resnet_retinanet as retinanet, custom_objects, download_imagenet
elif 'mobilenet' in sys.argv[1]:
from keras_retinanet.models.mobilenet import mobilenet_retinanet as retinanet, custom_objects, download_imagenet
elif 'vgg' in sys.argv[1]:
from keras_retinanet.models.vgg import vgg_retinanet as retinanet, custom_objects, download_imagenet
elif 'densenet' in sys.argv[1]:
from keras_retinanet.models.densenet import densenet_retinanet as retinanet, custom_objects, download_imagenet
else:
raise NotImplementedError('Backbone \'{}\' not implemented.'.format(sys.argv[1]))
weights = sys.argv[2]
_, _, model = create_models(
backbone_retinanet=retinanet,
backbone=sys.argv[1],
num_classes=12,
weights=weights,
multi_gpu=False,
freeze_backbone=False
)
# print model summary
print(model.summary())
# ## Run detection on example
# In[5]:
# load image
image = read_image_bgr('./examples/test.jpg')
def train_main(args=None):
# parse arguments
if args is None:
args = sys.argv[1:]
args = train.parse_args(args)
# create object that stores backbone information
backbone = models.backbone(args.backbone)
# make sure keras is the minimum required version
train.check_keras_version()
# optionally choose specific GPU
if args.gpu:
os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu
keras.backend.tensorflow_backend.set_session(train.get_session())
# create the generators
train_generator, validation_generator = train.create_generators(args)
# 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 = train.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 = train.create_callbacks(
model,
training_model,
prediction_model,
validation_generator,
args,
)
callbacks = add_classification_callbacks(args, callbacks, None)
# start training
training_model.fit_generator(generator=train_generator,
steps_per_epoch=args.steps,
epochs=args.epochs,
verbose=1,
callbacks=callbacks,
initial_epoch=args.initial_epoch)
# cleanup at the end of every epoch since we keep loading prediction models
del training_model
del model
del prediction_model
K.clear_session()
