pool_size=1000, \
min_nsamples=100 )
dg.start()
Xtrain = np.empty((batch_size, dim, dim, 3), dtype='single')
Ytrain = np.empty((int(batch_size), int(dim / model_stride),
int(dim / model_stride), int(2 * 4 + 1)))
model_path_backup = '%s/%s_backup' % (outdir, netname)
model_path_final = '%s/%s_final' % (outdir, netname)
for it in range(iterations):
print('Iter. %d (of %d)' % (it + 1, iterations))
Xtrain, Ytrain = dg.get_batch(batch_size)
train_loss = model.train_on_batch(Xtrain, Ytrain)
print('\tLoss: %f' % train_loss)
# Save model every 1000 iterations
if (it + 1) % 1000 == 0:
print('Saving model (%s)' % model_path_backup)
save_model(model, model_path_backup)
print('Stopping data generator')
dg.stop()
print('Saving model (%s)' % model_path_final)
save_model(model, model_path_final)
backbone_layers = {
'backbone_' + layer.name: layer
for layer in backbone.layers
}
for layer in model.layers:
if layer.name in backbone_layers:
print('setting ' + layer.name)
layer.set_weights(backbone_layers[layer.name].get_weights())
return model
if __name__ == '__main__':
modules = [
func.replace('create_model_', '')
for func in dir(sys.modules[__name__]) if 'create_model_' in func
]
assert sys.argv[1] in modules, \
'Model name must be on of the following: %s' % ', '.join(modules)
modelf = getattr(sys.modules[__name__], 'create_model_' + sys.argv[1])
print('Creating model %s' % sys.argv[1])
model = modelf()
print('Finished')
print('Saving at %s' % sys.argv[2])
save_model(model, sys.argv[2])
summary.value.add(tag='mAP_pascal', simple_value=mAP_pascal)
precision_car, recall_car = indicadores_validacao.precision_recall_car(
)
summary.value.add(tag='precision/precision car',
simple_value=precision_car)
summary.value.add(tag='recall/recall car', simple_value=recall_car)
summary.value.add(
tag='fn/false negative car',
simple_value=indicadores_validacao.false_negative_car)
precision_moto, recall_moto = indicadores_validacao.precision_recall_moto(
)
summary.value.add(tag='precision/precision moto',
simple_value=precision_moto)
summary.value.add(tag='recall/recall moto',
simple_value=recall_moto)
summary.value.add(
tag='fn/false negative moto',
simple_value=indicadores_validacao.false_negative_moto)
summary_writer.add_summary(summary, int(it + 1 / 100))
if best_precision < precision_car:
save_model(model, model_path_best_precision)
best_precision = precision_car
save_model(model, model_path_backup)
total_loss_it = 0
print('Stopping data generator')
dg.stop()
print('Saving model (%s)' % model_path_final)
save_model(model, model_path_final)
x = np.array(X)
y = np.array(Y)
train_generator = batch_generator(x, y, batch_size=args.batch_size)
callbacks = [tf.keras.callbacks.LearningRateScheduler(lr_schedule)]
model.compile(loss=loss, optimizer=opt)
model.fit_generator(train_generator,
steps_per_epoch=(x.shape[0] // args.batch_size),
epochs=args.epochs,
callbacks=callbacks)
print('Stopping data generator')
logger.info('Stopping data generator')
print('Saving model (%s)' % model_path_final)
logger.info('Saving model (%s)' % model_path_final)
save_model(model, model_path_final)
model.save(tf_path_final)
if args.prune_model:
callbacks.append(tfmot.sparsity.keras.UpdatePruningStep())
callbacks.append(
tfmot.sparsity.keras.PruningSummaries(log_dir=log_dir))
pruning_schedule = tfmot.sparsity.keras.PolynomialDecay(
initial_sparsity=args.initial_sparsity,
final_sparsity=args.final_sparsity,
begin_step=args.begin_step,
end_step=args.end_step)
model = tfmot.sparsity.keras.prune_low_magnitude(
model, pruning_schedule=pruning_schedule)
model.compile(loss=loss, optimizer=opt)
model.fit_generator(train_generator,
def create_model(args):
if args.model == 'eccv':
model = create_model_eccv()
else:
model = create_model_mobnet()
return model
if __name__ == '__main__':
args = get_args()
if args.use_colab:
from google.colab import drive
drive.mount('/content/gdrive')
OUTPUT_DIR = '/content/gdrive/My Drive/lpd/{}_{}_{}_{}_{}'.format(
args.image_size, args.epochs, args.prune_model,
args.initial_sparsity, args.final_sparsity)
if not os.path.isdir(OUTPUT_DIR): os.makedirs(OUTPUT_DIR)
model_name = '{}/{}'.format(OUTPUT_DIR, args.model)
assert (args.model == 'eccv' or args.model == 'mobnet'
), 'Model name must be on of the following: eccv or mobnet'
model = create_model(args)
print('Saving at %s' % model_name)
logger.info('Saving at %s' % model_name)
save_model(model, model_name)
