def predict(image_size, alphabet, max_sequence_length, max_lines):
img_w, img_h = image_size
images_input = tf.placeholder(shape=(1, img_h, img_w, 1), dtype=tf.float32)
sequences_input = tf.placeholder(shape=(1, max_sequence_length), dtype=tf.int32)
is_training = tf.constant(False, dtype=tf.bool)
add_eos = tf.constant(False, dtype=tf.bool)
model = Model(
images_input,
sequences_input,
is_training,
add_eos,
max_sequence_length,
alphabet,
alignments_type='full')
endpoints = model.endpoints()
test_generator = BatchGenerator(
size=image_size,
alphabet=alphabet,
max_sequence_length=max_sequence_length,
max_lines=3,
batch_size=1)
saver = tf.train.Saver()
with tf.Session() as sess:
init = tf.global_variables_initializer()
sess.run(init)
ckpt = tf.train.get_checkpoint_state('train/')
if ckpt and ckpt.model_checkpoint_path:
saver.restore(sess, ckpt.model_checkpoint_path)
else:
raise Exception('Cannot load checkpoint')
for imgs, seqs in test_generator.generate_batch():
predictions, alignments = sess.run([endpoints['predictions'], endpoints['alignments']], feed_dict={images_input: imgs})
img = np.squeeze(imgs[0])
predicted_text = ''.join([alphabet[x] for x in predictions[0] if x < len(alphabet)])
print("Predicted: {}".format(predicted_text))
font = cv2.FONT_HERSHEY_SIMPLEX
for ind, alignment in enumerate(alignments[0]):
if ind == len(predicted_text):
break
h, w = img.shape[:2]
img_al = cv2.resize(alignment, (w, h), interpolation=cv2.INTER_AREA)
highlighted = cv2.resize((img + img_al * 2) / 3., (500, 300), interpolation=cv2.INTER_AREA)
font = cv2.FONT_HERSHEY_SIMPLEX
cv2.putText(highlighted, predicted_text[ind], (50, 50), font, 2, (255,255,255), 2, cv2.LINE_AA)
cv2.imshow('alignment', highlighted)
k = cv2.waitKey(1000) & 0xFF
if k == 27:
break
k = cv2.waitKey(0) & 0xFF
if k == 27:
break
def train(model):
model.compile(optimizer=tf.keras.optimizers.Adam(lr=1e-4),
loss=[smooth_l1, focal],
metrics=None)
print(model.summary())
for var in model.variables:
print(var.name + '___' + str(var.shape))
pass
from generator import BatchGenerator
train_data_generator = BatchGenerator(train_ann_fnames, train_img_dir,
LABELS, batch_size)
val_data_generator = BatchGenerator(val_ann_fnames, val_img_dir, LABELS,
batch_size)
callbacks = [ #TrainCallback(),
#tf.keras.callbacks.LearningRateScheduler(schedule=lr_schedule, verbose=1),
#tf.keras.callbacks.TensorBoard(log_dir=log_dir, histogram_freq=0, write_graph=True, write_images=False),
tf.keras.callbacks.ModelCheckpoint(os.path.join(
log_dir,
"retinanet_voc_{epoch:02d}_loss-{loss:.4f}_val_loss-{val_loss:.4f}.h5"
),
monitor='val_loss',
verbose=1,
save_best_only=True,
save_weights_only=True,
save_freq='epoch')
]
model.fit_generator(train_data_generator,
epochs=100,
callbacks=callbacks,
validation_data=val_data_generator)
pass
def train():
voc_path = 'voc'
file_list_train = get_data_paths('train')
file_list_test = get_data_paths('test')
line_parser = MbtiParser()
train_generator = BatchGenerator(file_list_train,
line_parser,
batch_size=batch_size_train,
build_voc=build_voc,
voc_path=voc_path,
max_sentence_length=max_sentence_length)
#Do not build vocabulary for testing
test_generator = BatchGenerator(file_list_test,
line_parser,
batch_size=batch_size_test,
build_voc=False,
max_sentence_length=max_sentence_length,
voc_path=voc_path)
print("vocab_size {}".format(train_generator.vocab_size))
cnn = CnnTextClassifier(**cnn_hyperparameters)
cnn.fit_generator(train_generator, test_generator)
def _main_(args):
config_path = args.conf
with open(config_path) as config_buffer:
config = json.loads(config_buffer.read())
makedirs(os.path.dirname(config['train']['cache_name']))
train_ints, labels = parse_voc_annotation(config['train']['train_annot_folder'],
config['train']['train_image_folder'],
config['train']['cache_name'],
config['model']['labels'])
# valid_ints, _ = parse_voc_annotation(config['valid']['valid_annot_folder'], config['valid']['valid_image_folder'], config['valid']['cache_name'], config['model']['labels'])
instances = train_ints
max_box_per_image = max([len(inst['object']) for inst in instances])
print(list(labels.keys()))
train_generator = BatchGenerator(
instances = instances,
anchors = config['model']['anchors'],
labels = list(labels.keys()),
downsample = 32, # ratio between network input's size and network output's size, 32 for YOLOv3
max_box_per_image = max_box_per_image,
batch_size = 1,
min_net_size = config['model']['min_input_size'],
max_net_size = config['model']['max_input_size'],
norm = None
)
valid_generator = BatchGenerator(
instances = instances,
anchors = config['model']['anchors'],
labels = list(labels.keys()),
downsample = 32, # ratio between network input's size and network output's size, 32 for YOLOv3
max_box_per_image = max_box_per_image,
batch_size = 1,
min_net_size = config['model']['min_input_size'],
max_net_size = config['model']['max_input_size'],
norm = None,
infer_sz = config['model']['infer_shape']
)
for i in range(len(instances)):
timg = train_generator[i][0]
vimg = valid_generator[i][0]
timg = cv2.resize(timg, (640, 480))
vimg = cv2.resize(vimg, (640, 480))
cv2.imshow('1', np.vstack((timg.astype(np.uint8), vimg.astype(np.uint8))))
if cv2.waitKey(0) == 27:
break
def predict():
file_list_predict = get_data_paths('predict')
line_parser = MbtiParser()
predict_generator = BatchGenerator(file_list_predict,
line_parser,
batch_size=batch_size_predict,
build_voc=False,
max_sentence_length=max_sentence_length,
voc_path=voc_path)
cnn = CnnTextClassifier(**cnn_hyperparameters)
pred_dic = cnn.predict(predict_generator)
plt.figure()
plot_confusion_matrix(pred_dic['ground_truth'],
pred_dic['predictions'],
list(range(num_classes)),
title='Confusion matrix, without normalization')
plt.figure()
plot_confusion_matrix(pred_dic['ground_truth'],
pred_dic['predictions'],
list(range(num_classes)),
title='Confusion matrix, with normalization',
normalize=True)
plt.show()
def _main_(args):
config_path = args.conf
with open(config_path) as config_buffer:
config = json.loads(config_buffer.read())
###############################
# Create the validation generator
###############################
valid_ints, labels = parse_voc_annotation(
config['valid']['valid_annot_folder'],
config['valid']['valid_image_folder'], config['valid']['cache_name'],
config['model']['labels'])
labels = labels.keys() if len(
config['model']['labels']) == 0 else config['model']['labels']
labels = sorted(labels)
valid_generator = BatchGenerator(
instances=valid_ints,
anchors=config['model']['anchors'],
labels=labels,
downsample=
32, # ratio between network input's size and network output's size, 32 for YOLOv3
max_box_per_image=0,
batch_size=config['train']['batch_size'],
min_net_size=config['model']['min_input_size'],
max_net_size=config['model']['max_input_size'],
shuffle=True,
jitter=0.0,
norm=normalize)
###############################
# Load the model and do evaluation
###############################
os.environ['CUDA_VISIBLE_DEVICES'] = config['train']['gpus']
h5_files = []
for root, dirs, files in os.walk('.'):
for weights in files:
if weights[-3:] == '.h5':
if weights[:6] == 'helmet':
h5_files.append(weights)
print(h5_files)
for i in h5_files:
infer_model = load_model(i)
# compute mAP for all the classes
average_precisions = evaluate(infer_model, valid_generator)
# print the score
for label, average_precision in average_precisions.items():
print(labels[label] + ': {:.4f}'.format(average_precision))
print('mAP: {:.4f} of weight {}'.format(
sum(average_precisions.values()) / len(average_precisions), i))
def _main_(args):
config_path = args.conf
with open(config_path) as config_buffer:
config = json.loads(config_buffer.read())
print(config['valid']['valid_annot_folder'])
###############################
# Create the validation generator
###############################
valid_ints, labels = parse_voc_annotation(
config['valid']['valid_annot_folder'],
config['valid']['valid_image_folder'], config['valid']['cache_name'],
config['model']['labels'])
labels = labels.keys() if len(
config['model']['labels']) == 0 else config['model']['labels']
labels = sorted(labels)
valid_generator = BatchGenerator(
instances=valid_ints,
anchors=config['model']['anchors'],
labels=labels,
downsample=
32, # ratio between network input's size and network output's size, 32 for YOLOv3
max_box_per_image=0,
batch_size=config['train']['batch_size'],
min_net_size=config['model']['min_input_size'],
max_net_size=config['model']['max_input_size'],
shuffle=True,
jitter=0.0,
norm=normalize)
###############################
# Load the model and do evaluation
###############################
os.environ['CUDA_VISIBLE_DEVICES'] = config['train']['gpus']
infer_model = load_model(config['train']['saved_weights_name'])
# compute mAP for all the classes
average_precisions = evaluate(infer_model,
valid_generator,
iou_threshold=iou_threshold,
obj_thresh=obj_thresh,
nms_thresh=nms_thresh,
net_h=net_h,
net_w=net_w)
# print("recall : {}".format(recall))
# print("precision : {}".format(precision))
# plt.plot(recall, precision)
# plt.show()
# print the score
for label, average_precision in average_precisions.items():
print(labels[label] + ': {:.4f}'.format(average_precision))
print('mAP: {:.4f}'.format(
sum(average_precisions.values()) / len(average_precisions)))
def evaluate_main_(args):
config_path = args.conf
yolo_config_file_exit('pass') \
if os.path.isfile(config_path) \
else yolo_config_file_exit('fail')
with open(config_path) as config_buffer:
config = json.loads(config_buffer.read())
###############################
# Create the validation generator
###############################
valid_ints, labels = parse_voc_annotation(
config['valid']['valid_annot_folder'],
config['valid']['valid_image_folder'], config['valid']['cache_name'],
config['model']['labels'])
labels = labels.keys() if len(config['model']['labels']) == 0 \
else config['model']['labels']
labels = sorted(labels)
valid_generator = BatchGenerator(
instances=valid_ints,
anchors=config['model']['anchors'],
labels=labels,
downsample=32,
# ratio between network input's size and network output's size, 32 for YOLOv3
max_box_per_image=0,
batch_size=config['train']['batch_size'],
min_net_size=config['model']['min_input_size'],
max_net_size=config['model']['max_input_size'],
shuffle=True,
jitter=0.0,
norm=normalize)
###############################
# Load the model and do evaluation
###############################
#os.environ['CUDA_VISIBLE_DEVICES'] = config['train']['gpus']
infer_model = load_model(config['train']['saved_weights_name'])
# compute mAP for all the classes
average_precisions = evaluate(infer_model, valid_generator)
# print the score
for label, average_precision in average_precisions.items():
print(labels[label] + ': {:.4f}'.format(average_precision))
print('mAP: {:.4f}'.format(
sum(average_precisions.values()) / len(average_precisions)))
try:
yolo_process_exit('pass')
except RuntimeError as e:
yolo_process_exit('fail')
def train(config, model, tokenizer):
columns = ['epoch', 'trn_cost', 'trn_acc', 'val_cost', 'val_acc', 'val_f1']
results = {key: [] for key in columns}
train_generator = BatchGenerator('train', config, tokenizer)
dev_generator = BatchGenerator('dev', config, tokenizer)
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
for epoch in range(1, config.epochs+1):
epoch_train_results = model.train(sess, epoch, config, train_generator)
epoch_val_results = model.validate(sess, epoch, config, dev_generator)
epoch_results = [epoch] + epoch_train_results + epoch_val_results
for key, value in zip(results.keys(), epoch_results):
results[key].append(value)
model_name = str(epoch) + '-acc' + str(epoch_val_results[1]) + '-f1' + str(epoch_val_results[2])
model.save(sess, config.model_save_path, model_name)
return results
def train(self):
"""
Returns a trained word2vec model
"""
generator_param = {
'parser': self.parser,
'exist_labels': False,
'train_w2v': True,
'data_path': self.data_path,
'header': True,
'batch_size': self.batch_size,
'one_pass': True
}
self.generator = BatchGenerator(**generator_param)
model = gensim.models.Word2Vec(
iter=1, size=self.embedding_size, window=5,
min_count=5) # an empty model, no training yet
print("building vocabulary...")
model.build_vocab(
self.generator) # can be a non-repeatable, 1-pass generator
# we only consider words appearing in the input documents, this is useful when
# working with large pre-trained word2vec models, for memory issues.
self.dic = {k: i.index for (k, i) in model.wv.vocab.items()}
if self.pre_trained:
# override model object if using a pre-trained model
print("loading word2vec model...")
model = gensim.models.KeyedVectors.load_word2vec_format(
self.pre_trained_path, binary=True)
else:
print("training word2vec model...")
model.train(self.generator,
total_examples=model.corpus_count,
epochs=self.n_epochs
) # can be a non-repeatable, 1-pass generator
return model
def _main_(args):
config_path = args.conf
weights = args.weights
init_session(1.0)
with open(config_path) as config_buffer:
config = json.loads(config_buffer.read())
###############################
# Create the validation generator
###############################
valid_ints, labels = parse_voc_annotation(config['eval']['annot_folder'],
config['eval']['image_folder'],
config['eval']['cache_name'],
config['model']['labels'])
valid_ints, labels = replace_all_labels_2_one(valid_ints, 'sign')
labels = list(labels.keys())
config['model']['labels'] = labels
# labels = labels.keys() if len(config['model']['labels']) == 0 else config['model']['labels']
# labels = sorted(labels)
valid_generator = BatchGenerator(
instances=valid_ints,
anchors=config['model']['anchors'],
labels=labels,
downsample=config['model']
['downsample'], # ratio between network input's size and network output's size, 32 for YOLOv3
max_box_per_image=0,
batch_size=config['train']['batch_size'],
min_net_size=config['train']['min_input_size'],
max_net_size=config['train']['max_input_size'],
shuffle=False,
jitter=0.0,
norm=image_normalize)
yolo_model = yolo.YOLO_Model(config['model'], )
yolo_model.load_weights(weights)
average_precisions, _ = yolo_model.evaluate_generator(valid_generator,
verbose=True)
c_ut.print_predicted_average_precisions(average_precisions)
def _main_(args):
config_path = args.conf
with open(config_path) as config_buffer:
config = json.loads(config_buffer.read())
###############################
# Create the validation generator
###############################
valid_ints, labels = parse_voc_annotation(
config['valid']['valid_annot_folder'],
config['valid']['valid_image_folder'], config['model']['labels'])
labels = sorted(labels.keys())
valid_generator = BatchGenerator(
instances=valid_ints,
anchors=config['model']['anchors'],
labels=labels,
downsample=
32, # ratio between network input's size and network output's size, 32 for YOLOv3
max_box_per_image=config['model']['max_box_per_image'],
batch_size=config['train']['batch_size'],
min_net_size=config['model']['min_input_size'],
max_net_size=config['model']['max_input_size'],
shuffle=True,
jitter=0.0,
norm=normalize)
###############################
# Load the model and do evaluation
###############################
infer_model = load_model(config['train']['saved_weights_name'])
# compute mAP for all the classes
average_precisions = evaluate(infer_model, valid_generator)
# print the score
for label, average_precision in average_precisions.items():
print(labels[label] + ': {:.4f}'.format(average_precision))
print('mAP: {:.4f}'.format(
sum(average_precisions.values()) / len(average_precisions)))
# 训练集采用generator的方式产生
# 测试集采用yield的方式产生
LEARNINF_RATE = 1e-4 #学习率
EPOCHES = 10 #训练轮数
BATCH_SIZE = 128 #批量大小
N_CLASSES = 10 #标签的维度
DROPOUT = 0.5 #dropout概率
IMAGE_H = 224 #图片大小
IMAGE_W = 224
model_path = "model"
model_name = "cifar10.ckpt"
# 训练集数据生成器（测试集采用yield的方式产生）
train_data = BatchGenerator(target_size=(IMAGE_H, IMAGE_W),
batch_size=BATCH_SIZE)
# 创建placeholder
inputs_placeholder = tf.placeholder(dtype=tf.float32,
shape=[None, IMAGE_H, IMAGE_W, 3],
name="INPUTS")
# 理论上这里写tf.int32更合适,写tf.float32也行
labels_placeholder = tf.placeholder(dtype=tf.int32,
shape=[None, N_CLASSES],
name="INPUTS")
keep_prob_placeholder = tf.placeholder(tf.float32, name='keep_prob')
alex_outputs = AlexNet(inputs_placeholder, N_CLASSES, keep_prob_placeholder)
cost, accuracy = AlexNet_loss(alex_outputs, labels_placeholder)
train_op = tf.train.AdamOptimizer(LEARNINF_RATE).minimize(cost)
def _main_(args):
config_path = args.conf
with open(config_path) as config_buffer:
config = json.loads(config_buffer.read())
###############################
# Parse the annotations
###############################
train_ints, valid_ints, labels, max_box_per_image = create_training_instances(
config['train']['train_annot_folder'],
config['train']['train_image_folder'], config['train']['cache_name'],
config['valid']['valid_annot_folder'],
config['valid']['valid_image_folder'], config['valid']['cache_name'],
config['model']['labels'])
print('\nTraining on: \t' + str(labels) + '\n')
###############################
# Create the generators
###############################
train_generator = BatchGenerator(
instances=train_ints,
anchors=config['model']['anchors'],
labels=labels,
downsample=
32, # ratio between network input's size and network output's size, 32 for YOLOv3
max_box_per_image=max_box_per_image,
batch_size=config['train']['batch_size'],
min_net_size=config['model']['min_input_size'],
max_net_size=config['model']['max_input_size'],
shuffle=True,
jitter=0.3,
norm=normalize)
valid_generator = BatchGenerator(
instances=valid_ints,
anchors=config['model']['anchors'],
labels=labels,
downsample=
32, # ratio between network input's size and network output's size, 32 for YOLOv3
max_box_per_image=max_box_per_image,
batch_size=config['train']['batch_size'],
min_net_size=config['model']['min_input_size'],
max_net_size=config['model']['max_input_size'],
shuffle=True,
jitter=0.0,
norm=normalize)
###############################
# Create the model
###############################
if os.path.exists(config['train']['saved_weights_name']):
config['train']['warmup_epochs'] = 0
warmup_batches = config['train']['warmup_epochs'] * (
config['train']['train_times'] * len(train_generator))
os.environ['CUDA_VISIBLE_DEVICES'] = config['train']['gpus']
multi_gpu = len(config['train']['gpus'].split(','))
train_model, infer_model = create_model(
nb_class=len(labels),
anchors=config['model']['anchors'],
max_box_per_image=max_box_per_image,
max_grid=[
config['model']['max_input_size'],
config['model']['max_input_size']
],
batch_size=config['train']['batch_size'],
warmup_batches=warmup_batches,
ignore_thresh=config['train']['ignore_thresh'],
multi_gpu=multi_gpu,
saved_weights_name=config['train']['saved_weights_name'],
lr=config['train']['learning_rate'],
grid_scales=config['train']['grid_scales'],
obj_scale=config['train']['obj_scale'],
noobj_scale=config['train']['noobj_scale'],
xywh_scale=config['train']['xywh_scale'],
class_scale=config['train']['class_scale'],
)
###############################
# Kick off the training
###############################
callbacks = create_callbacks(config['train']['saved_weights_name'],
config['train']['tensorboard_dir'],
infer_model)
history = train_model.fit_generator(
generator=train_generator,
steps_per_epoch=len(train_generator) *
config['train']['train_times'], #(train_images/4)*train_times
epochs=config['train']['nb_epochs'] + config['train']['warmup_epochs'],
verbose=2 if config['train']['debug'] else 1,
callbacks=callbacks,
workers=4,
max_queue_size=8,
validation_data=valid_generator,
validation_steps=len(valid_generator) * config['valid']['valid_times'])
# Prepare folder to save in
time = datetime.now()
time_str = time.strftime("%Y%m%d-%H:%M")
cwd = os.getcwd()
save_path = os.path.join(cwd, time_str)
print('Data saved in: ' + save_path)
makedirs(save_path)
# Copy and save config file
save_config_path = os.path.join(save_path, 'config.json')
shutil.copy2(config_path, save_config_path)
# plotting train data and saving mat file with data
plot_matlab(history, config['data']['plot_png'],
config['data']['save_mat'], save_path)
# Save the loaded models to .TXT
save_template_path = os.path.join(save_path, 'train_model_params.txt')
with open(save_template_path, 'w') as fh:
# Pass the file handle in as a lambda function to make it callable
train_model.summary(print_fn=lambda x: fh.write(x + '\n'))
# make a GPU version of infer_model for evaluation
if multi_gpu > 1:
infer_model = load_model(config['train']['saved_weights_name'])
###############################
# Run the evaluation
###############################
# compute mAP for all the classes
average_precisions = evaluate(infer_model, valid_generator)
# print the score
print('========== VALIDATION ==========')
for label, average_precision in average_precisions.items():
print(labels[label] + ': {:.4f}'.format(average_precision))
print('mAP: {:.4f}'.format(
sum(average_precisions.values()) / len(average_precisions)))
def _main_(args):
config_path = args.conf
with open(config_path) as config_buffer:
config = json.loads(config_buffer.read())
###############################
# Create the validation generator
###############################
valid_ints, labels = parse_voc_annotation(
config['valid']['valid_annot_folder'],
config['valid']['valid_image_folder'], config['valid']['cache_name'],
config['model']['labels'])
labels = labels.keys() if len(
config['model']['labels']) == 0 else config['model']['labels']
labels = sorted(labels)
valid_generator = BatchGenerator(
instances=valid_ints,
anchors=config['model']['anchors'],
labels=labels,
downsample=
32, # ratio between network input's size and network output's size, 32 for YOLOv3
max_box_per_image=0,
batch_size=config['train']['batch_size'],
min_net_size=config['model']['min_input_size'],
max_net_size=config['model']['max_input_size'],
shuffle=True,
jitter=0.0,
norm=normalize)
###############################
# Load the model and do evaluation
###############################
###############################
# Create the model
##############################
train_model, infer_model = create_yolov3_model(
nb_class=len(labels),
anchors=config['model']['anchors'],
max_box_per_image=0,
max_grid=[
config['model']['max_input_size'],
config['model']['max_input_size']
],
batch_size=config['train']['batch_size'],
warmup_batches=0,
ignore_thresh=config['train']['ignore_thresh'],
grid_scales=config['train']['grid_scales'],
obj_scale=config['train']['obj_scale'],
noobj_scale=config['train']['noobj_scale'],
xywh_scale=config['train']['xywh_scale'],
class_scale=config['train']['class_scale'],
)
os.environ['CUDA_VISIBLE_DEVICES'] = config['train']['gpus']
saved_weights_name = config['train']['saved_weights_name']
lr = config['train']['learning_rate'],
infer_model.load_weights(saved_weights_name)
optimizer = Adam(lr=lr, clipnorm=0.001)
infer_model.compile(loss=dummy_loss, optimizer=optimizer)
infer_model.summary()
#infer_model = load_model(config['train']['saved_weights_name'])
# compute mAP for all the classes
recall, precision, average_precisions = evaluate(infer_model,
valid_generator)
# print the score
for label, average_precision in average_precisions.items():
print(labels[label] + ': {:.4f}'.format(average_precision))
print('mAP: {:.4f}'.format(
sum(average_precisions.values()) / len(average_precisions)))
return recall, precision, average_precisions
def main():
# GPU
limit_keras_gpu_usage(settings.gpu_limit)
# configurations
global exp_name
exp_name = datetime.strftime(datetime.now(), '%y%m%d-%H%M%S')
opt = {
'width': settings.W,
'height': settings.H,
'n_classes': settings.n_classes,
'batch_size': settings.batch_size,
'epochs': settings.epochs,
'workers': settings.workers,
'wandb': settings.use_wandb,
'monitor': settings.monitor,
'mode': settings.mode
}
if settings.use_wandb:
wandb.init(
project="seg_keras",
name=exp_name,
config=opt, #TODO: opt
sync_tensorboard=True)
# Setup model directory
if not os.path.exists("trainings"):
os.makedirs("trainings")
if not os.path.exists(os.path.join('.', 'trainings', exp_name)):
os.makedirs(os.path.join('.', 'trainings', exp_name))
config_file_dst = os.path.join('.', 'trainings', exp_name,
os.path.basename(settings.CONFIG_PATH))
with open(config_file_dst, 'w') as f:
yaml.dump(opt, f, default_flow_style=False, default_style='')
if settings.use_wandb:
wandb.save(config_file_dst)
# Build data generators
train_gen = BatchGenerator(settings.DATA_PATH,
settings.batch_size,
mode='train',
n_classes=settings.n_classes)
valid_gen = BatchGenerator(settings.DATA_PATH,
settings.batch_size,
mode='valid',
n_classes=settings.n_classes)
# Initialize a model
cce = categorical_crossentropy
metrics = [MIOU(settings.n_classes), categorical_accuracy]
model_path = os.path.join('.', 'trainings', exp_name, exp_name + '.h5')
model = Deeplabv3(weights=None,
input_shape=(settings.H, settings.W, 3),
classes=settings.n_classes,
activation='softmax',
backbone='mobilenetv2')
model.summary()
model.compile(optimizer=Adam(lr=settings.lr, epsilon=1e-8, decay=1e-6),
sample_weight_mode="temporal",
loss=cce,
metrics=metrics)
#model.summary()
# training
model.fit_generator(train_gen,
steps_per_epoch=len(train_gen),
epochs=settings.epochs,
verbose=1,
callbacks=get_callbacks(model_path),
validation_data=valid_gen,
validation_steps=len(valid_gen),
max_queue_size=10,
workers=settings.workers,
use_multiprocessing=False)
# save trflite model
new_path = os.path.join('.', 'trainings', exp_name, exp_name + '.tflite')
convert_to_tflite(model_path, new_path)
if settings.use_wandb:
wandb.save(os.path.join('trainings', exp_name))
def _main_(args):
config_path = args.conf
with open(config_path) as config_buffer:
config = json.loads(config_buffer.read())
###############################
# Parse the annotations
###############################
train_ints, valid_ints, labels = create_training_instances(
config['train']['train_annot_folder'],
config['train']['train_image_folder'], config['train']['cache_name'],
config['valid']['valid_annot_folder'],
config['valid']['valid_image_folder'], config['valid']['cache_name'],
config['model']['labels'])
###############################
# Create the generators
###############################
train_generator = BatchGenerator(
instances=train_ints,
anchors=config['model']['anchors'],
labels=labels,
downsample=
32, # ratio between network input's size and network output's size, 32 for YOLOv3
max_box_per_image=config['model']['max_box_per_image'],
batch_size=config['train']['batch_size'],
min_net_size=config['model']['min_input_size'],
max_net_size=config['model']['max_input_size'],
shuffle=True,
jitter=0.3,
norm=normalize)
valid_generator = BatchGenerator(
instances=valid_ints,
anchors=config['model']['anchors'],
labels=labels,
downsample=
32, # ratio between network input's size and network output's size, 32 for YOLOv3
max_box_per_image=config['model']['max_box_per_image'],
batch_size=config['train']['batch_size'],
min_net_size=config['model']['min_input_size'],
max_net_size=config['model']['max_input_size'],
shuffle=True,
jitter=0.0,
norm=normalize)
###############################
# Create the model
###############################
if os.path.exists(config['train']['saved_weights_name']):
warmup_batches = 0 # no need warmup if the pretrained weight exists
else:
warmup_batches = config['train']['warmup_epochs'] * (config['train']['train_times']*len(train_generator) + \
config['valid']['valid_times']*len(valid_generator))
os.environ['CUDA_VISIBLE_DEVICES'] = config['train']['gpus']
multi_gpu = len(config['train']['gpus'].split(','))
train_model, infer_model = create_model(
nb_class=len(labels),
anchors=config['model']['anchors'],
max_box_per_image=config['model']['max_box_per_image'],
max_grid=[
config['model']['max_input_size'],
config['model']['max_input_size']
],
batch_size=config['train']['batch_size'],
warmup_batches=warmup_batches,
ignore_thresh=config['train']['ignore_thresh'],
multi_gpu=multi_gpu,
saved_weights_name=config['train']['saved_weights_name'])
###############################
# Kick off the training
###############################
optimizer = Adam(lr=config['train']['learning_rate'],
beta_1=0.9,
beta_2=0.999,
epsilon=1e-08,
decay=0.0)
train_model.compile(loss=dummy_loss, optimizer=optimizer)
callbacks = create_callbacks(config['train']['saved_weights_name'])
try:
train_model.fit_generator(generator=train_generator,
steps_per_epoch=len(train_generator) *
config['train']['train_times'],
epochs=config['train']['nb_epochs'] +
config['train']['warmup_epochs'],
verbose=2 if config['train']['debug'] else 1,
validation_data=valid_generator,
validation_steps=len(valid_generator) *
config['valid']['valid_times'],
callbacks=callbacks,
workers=4,
max_queue_size=8)
except:
pass
# load the best weight before early stop
train_model.load_weights(config['train']['saved_weights_name'])
if multi_gpu > 1:
# fix the saved model structure when multi_gpu > 1
train_model.get_layer("model_1").save(
config['train']['saved_weights_name'])
# load the best weight to the infer_model
infer_model.load_weights(config['train']['saved_weights_name'])
# save the weight with the model structure of infer_model
infer_model.save(config['train']['saved_weights_name'])
# make a GPU version of infer_model for evaluation
if multi_gpu > 1:
infer_model = load_model(config['train']['saved_weights_name'])
###############################
# Run the evaluation
###############################
# compute mAP for all the classes
average_precisions = evaluate(infer_model, valid_generator)
# print the score
for label, average_precision in average_precisions.items():
print(labels[label] + ': {:.4f}'.format(average_precision))
print('mAP: {:.4f}'.format(
sum(average_precisions.values()) / len(average_precisions)))
MIN_INPUT_SIZE = 608
DEBUG = True
max_box_per_image = max(
[len(inst['object']) for inst in (train_ints + valid_ints)])
labels = ['Opacity']
train_generator = BatchGenerator(
instances=train_ints,
anchors=ANCHORS,
labels=labels,
downsample=
32, # ratio between network input's size and network output's size, 32 for YOLOv3
max_box_per_image=max_box_per_image,
batch_size=BATCH_SIZE,
min_net_size=MIN_INPUT_SIZE,
max_net_size=MAX_INPUT_SIZE,
shuffle=True,
jitter=0.3,
norm=normalize)
valid_generator = BatchGenerator(
instances=valid_ints,
anchors=ANCHORS,
labels=labels,
downsample=
32, # ratio between network input's size and network output's size, 32 for YOLOv3
max_box_per_image=max_box_per_image,
batch_size=BATCH_SIZE,
"""
#得到最终的训练集测试集验证集（注意：这里没有tag_train）
X_train = sentences_train
X_tag_train = tags_train
y_train = labels_train
X_valid = sentences_dev
X_tag_valid = tags_dev
y_valid = labels_dev
X_test = Xend_sentence
X_tag_test = Xend_tag_test
y_test = yend_test
#得到batch数据
#data_test = BatchGenerator(Xend_sentence,Xend_tag_test, yend_test, shuffle=False)
print('Creating the data generator ...')
data_train = BatchGenerator(X_train, X_tag_train, y_train, shuffle=True)
data_valid = BatchGenerator(X_valid, X_tag_valid, y_valid, shuffle=False)
data_test = BatchGenerator(X_test, X_tag_test, y_test, shuffle=False)
print('Finished creating the data generator.')
###################################2.############################################
import tensorflow as tf
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
sess = tf.Session(config=config)
from tensorflow.contrib import rnn
import numpy as np
# ##################### config ######################
decay = 0.85
#定义分类
LABELS = ['0', "1", "2", "3", '4', '5', '6', '7', '8', "9"]
#定义样本路径
ann_dir = os.path.join(PROJECT_ROOT, "data", "ann", "*.xml")
img_dir = os.path.join(PROJECT_ROOT, "data", "img")
train_ann_fnames = glob.glob(ann_dir) #获取该路径下的xml文件
imgsize = 416
batch_size = 2
#制作数据集
generator = BatchGenerator(train_ann_fnames,
img_dir,
net_size=imgsize,
anchors=COCO_ANCHORS,
batch_size=2,
labels=LABELS,
jitter=False) #随机变化尺寸。数据增强
#定义训练参数
learning_rate = 1e-4 #定义学习率
num_epoches = 85 #定义迭代次数
save_dir = "./model" #定义模型路径
#循环整个数据集，进行loss值验证
def _loop_validation(model, generator):
n_steps = generator.steps_per_epoch
loss_value = 0
def _main_(args):
config_path = args.conf
with open(config_path) as config_buffer:
config = json.loads(config_buffer.read())
###############################
# Create the validation generator
###############################
valid_ints, labels = parse_voc_annotation(
config['valid']['valid_annot_folder'],
config['valid']['valid_image_folder'], config['valid']['cache_name'],
config['model']['labels'])
labels = labels.keys() if len(
config['model']['labels']) == 0 else config['model']['labels']
labels = sorted(labels)
valid_generator = BatchGenerator(
instances=valid_ints,
anchors=config['model']['anchors'],
labels=labels,
downsample=
32, # ratio between network input's size and network output's size, 32 for YOLOv3
max_box_per_image=0,
batch_size=config['train']['batch_size'],
min_net_size=config['model']['min_input_size'],
max_net_size=config['model']['max_input_size'],
shuffle=True,
jitter=0.0,
norm=normalize)
###############################
# Load the model and do evaluation
###############################
os.environ['CUDA_VISIBLE_DEVICES'] = config['train']['gpus']
infer_model = load_model(config['train']['saved_weights_name'],
compile=False)
# compute mAP for all the classes
average_precisions = evaluate(
infer_model,
test_generator,
iou_threshold=config['test']['iou_threshold'],
obj_thresh=config['test']['obj_thresh'])
# print the score
average_precisions = evaluate(infer_model, valid_generator)
ap = []
# print the mAP score
for label, average_precision in average_precisions.items():
print(labels[label] +
' average precision(AP): {:.6f}'.format(average_precision['ap']))
ap.append(average_precision['ap'])
print(labels[label] +
' recall: {:.6f}'.format(average_precision['recall']))
print(labels[label] +
' precision: {:.6f}'.format(average_precision['precision']))
print('[INFO] mAP: {:.6f}'.format(sum(ap) / len(ap)))
def _main():
config_path = './local_config.json'
LABELS = read_category()
with open(config_path) as config_buffer:
config = json.loads(config_buffer.read())
''' Parse annotations '''
config['model']['labels'] = LABELS
train_ints, valid_ints, labels, max_box_per_image = create_train_valid_set(
config['train']['train_annot_folder'],
config['train']['train_image_folder'],
config['valid']['valid_annot_folder'],
config['valid']['valid_image_folder'], config['model']['labels'])
''' Create generators '''
# check if images are normal after BatchGenerator
batches = BatchGenerator(instances=np.append(train_ints, valid_ints),
anchors=config['model']['anchors'],
labels=labels,
downsample=32,
max_box_per_image=max_box_per_image,
batch_size=config['train']['batch_size'],
shuffle=False,
jitter=False)
img = batches[0][0][0][5]
# plt.imshow(img.astype('uint8'))
train_generator = BatchGenerator(
instances=train_ints,
anchors=config['model']['anchors'],
labels=labels,
downsample=
32, # ratio between network input's size and network output's size, 32 for YOLOv3
max_box_per_image=max_box_per_image,
batch_size=config['train']['batch_size'],
# min_net_size=config['model']['min_input_size'],
# max_net_size=config['model']['max_input_size'],
shuffle=True,
jitter=True, # add 10% noise for each image for training
norm=normalize)
img = train_generator[0][0][0][5]
# plt.imshow(img.astype('float'))
valid_generator = BatchGenerator(
instances=valid_ints,
anchors=config['model']['anchors'],
labels=labels,
downsample=
32, # ratio between network input's size and network output's size, 32 for YOLOv3
max_box_per_image=max_box_per_image,
batch_size=config['train']['batch_size'],
# min_net_size=config['model']['min_input_size'],
# max_net_size=config['model']['max_input_size'],
shuffle=True,
jitter=False,
norm=normalize)
''' Create the model '''
if os.path.exists(config['train']['saved_weights_name']):
config['train']['warmup_epochs'] = 0
warmup_batches = config['train']['warmup_epochs'] * (
config['train']['train_times'] * len(train_generator))
os.environ['CUDA_VISIBLE_DEVICES'] = config['train']['gpus']
multi_gpu = len(config['train']['gpus'].split(','))
train_model, infer_model = create_model(
nb_class=len(labels),
anchors=config['model']['anchors'],
max_box_per_image=max_box_per_image,
max_grid=[
config['model']['max_input_size'],
config['model']['max_input_size']
],
batch_size=config['train']['batch_size'],
warmup_batches=warmup_batches,
ignore_thresh=config['train']['ignore_thresh'],
multi_gpu=multi_gpu,
saved_weights_name=config['train']['saved_weights_name'],
lr=config['train']['learning_rate'],
grid_scales=config['train']['grid_scales'],
obj_scale=config['train']['obj_scale'],
noobj_scale=config['train']['noobj_scale'],
xywh_scale=config['train']['xywh_scale'],
class_scale=config['train']['class_scale'],
)
print('\ntrain_model: \n')
print(train_model.summary())
print('\ninfer_model: \n')
print(infer_model.summary())
''' Kick off the training '''
callbacks = create_callbacks(config['train']['saved_weights_name'],
config['train']['tensorboard_dir'],
infer_model)
train_model.fit_generator(
generator=train_generator,
steps_per_epoch=len(
train_generator), # * config['train']['train_times'],
epochs=config['train']['nb_epochs'] + config['train']['warmup_epochs'],
verbose=2 if config['train']['debug'] else 1,
callbacks=callbacks,
workers=16,
max_queue_size=8)
# make a GPU version of infer_model for evaluation
if multi_gpu > 1:
infer_model = load_model(config['train']['saved_weights_name'])
''' Evaluate the result '''
# compute mAP for all the classes
average_precisions = evaluate(infer_model, valid_generator)
# print the score
for label, average_precision in average_precisions.items():
print(labels[label] + ': {:.4f}'.format(average_precision))
print('mAP: {:.4f}'.format(
sum(average_precisions.values()) / len(average_precisions)))
def main(args):
'''
There are 5 simple steps to this program
'''
# 1. combine all data into 2 dataframes (train, valid)
print("Getting data from arguments")
train_dataprops, df_train = combine_all_wavs_and_trans_from_csvs(
args.train_files)
valid_dataprops, df_valid = combine_all_wavs_and_trans_from_csvs(
args.valid_files)
# check any special data model requirments e.g. a spectrogram
if (args.model_arch == 1):
model_input_type = "mfcc"
elif (args.model_arch == 2 or args.model_arch == 5):
print("Spectrogram required")
# spectrogram = True
model_input_type = "spectrogram"
else:
model_input_type = "mfcc"
## 2. init data generators
print("Creating data batch generators")
traindata = BatchGenerator(dataframe=df_train,
training=True,
batch_size=args.batchsize,
model_input_type=model_input_type)
validdata = BatchGenerator(dataframe=df_valid,
training=False,
batch_size=args.batchsize,
model_input_type=model_input_type)
inputs, outputs = traindata.get_batch(0)
input_shape = inputs['the_input'].shape[1:]
output_shape = inputs['the_labels'].shape[1:]
output_dir = os.path.join('checkpoints/results', 'model')
if not os.path.isdir(output_dir):
os.makedirs(output_dir)
## 3. Load existing or create new model
if args.loadcheckpointpath:
# load existing
print("Loading model")
cp = args.loadcheckpointpath
assert (os.path.isdir(cp))
model_path = os.path.join(cp, "model")
# assert(os.path.isfile(model_path))
model = load_model_checkpoint(model_path)
print("Model loaded")
else:
# new model recipes here
print('New model DS{}'.format(args.model_arch))
if (args.model_arch == 0):
# DeepSpeech1 with Dropout
model = ds1_dropout(input_dim=26,
fc_size=args.fc_size,
rnn_size=args.rnn_size,
dropout=[0.1, 0.1, 0.1],
output_dim=29)
elif (args.model_arch == 1):
# DeepSpeech1 - no dropout
model = ds1(input_dim=26,
fc_size=args.fc_size,
rnn_size=args.rnn_size,
output_dim=29)
elif (args.model_arch == 2):
# DeepSpeech2 model
model = ds2_gru_model(input_dim=161,
fc_size=args.fc_size,
rnn_size=args.rnn_size,
output_dim=29)
elif (args.model_arch == 3):
# own model
model = ownModel(input_shape,
output_shape,
fc_size=args.fc_size,
rnn_size=args.rnn_size,
dropout=[0.1, 0.1, 0.1],
output_dim=29)
elif (args.model_arch == 4):
# graves model
model = graves(input_dim=26,
rnn_size=args.rnn_size,
output_dim=29,
std=0.5)
elif (args.model_arch == 5):
# cnn city
model = cnn_city(input_dim=161,
fc_size=args.fc_size,
rnn_size=args.rnn_size,
output_dim=29)
elif (args.model_arch == 6):
# constrained model
model = const(input_dim=26,
fc_size=args.fc_size,
rnn_size=args.rnn_size,
output_dim=29)
else:
raise ("model not found")
print(model.summary(line_length=140))
# required to save the JSON
save_model(model, output_dir)
if (args.opt.lower() == 'sgd'):
opt = SGD(lr=args.learning_rate,
decay=1e-6,
momentum=0.9,
nesterov=True,
clipnorm=5)
elif (args.opt.lower() == 'adam'):
opt = Adam(lr=args.learning_rate,
beta_1=0.9,
beta_2=0.999,
epsilon=1e-8,
clipnorm=5)
elif (args.opt.lower() == 'nadam'):
opt = Nadam(lr=args.learning_rate,
beta_1=0.9,
beta_2=0.999,
epsilon=1e-8,
clipnorm=5)
else:
raise Exception("optimiser not recognised")
model.compile(optimizer=opt, loss=ctc)
## 4. train
if args.train_steps == 0:
args.train_steps = len(df_train.index) // args.batchsize
# print(args.train_steps)
# we use 1/xth of the validation data at each epoch end to test val score
if args.valid_steps == 0:
args.valid_steps = (len(df_valid.index) // args.batchsize)
# print(args.valid_steps)
if args.memcheck:
cb_list = [MemoryCallback()]
else:
cb_list = []
if args.tensorboard:
tb_cb = TensorBoard(log_dir='./tensorboard/{}/'.format(args.name),
write_graph=False,
write_images=True)
cb_list.append(tb_cb)
y_pred = model.get_layer('ctc').input[0]
input_data = model.get_layer('the_input').input
report = K.function([input_data, K.learning_phase()], [y_pred])
report_cb = ReportCallback(report, validdata, model, args.name, save=True)
cb_list.append(report_cb)
model.fit_generator(
generator=traindata.next_batch(),
steps_per_epoch=args.train_steps,
epochs=args.epochs,
callbacks=cb_list,
validation_data=validdata.next_batch(),
validation_steps=args.valid_steps,
)
## These are the most important metrics
print("Mean WER :", report_cb.mean_wer_log)
print("Mean LER :", report_cb.mean_ler_log)
print("NormMeanLER:", report_cb.norm_mean_ler_log)
# export to csv?
K.clear_session()
def main(argv):
if (len(sys.argv) != 3):
print('Usage ./train.py [root_dir] [config.yml]')
sys.exit(1)
#Load data
root_dir = argv[1] + '/' #in case we forgot
print('Opening file' + root_dir + argv[2])
with open(root_dir + argv[2], 'r') as configfile:
config = yaml.safe_load(configfile)
image_dir = root_dir + config['data_dir']
train_dir = root_dir + config['data_dir']
train_image_folder = root_dir + config['data_dir']
weights_dir = root_dir + config['weights_dir']
your_weights = weights_dir + config['specific_weights']
generic_weights = weights_dir + config['generic_weights']
trained_weights = weights_dir + config['trained_weights']
list_of_train_file = train_dir + config['checked_annotations_fname']
list_of_train_files = '/annotations-checked.yml'
train_files_regex = config['generic_train_files_regex']
FINE_TUNE = config['FINE_TUNE']
TEST_RUN = config['TEST_RUN']
LABELS = config['LABELS']
IMAGE_H = config['IMAGE_H']
IMAGE_W = config['IMAGE_W']
NO_OBJECT_SCALE = config['NO_OBJECT_SCALE']
OBJECT_SCALE = config['OBJECT_SCALE']
COORD_SCALE = config['COORD_SCALE']
CLASS_SCALE = config['CLASS_SCALE']
valid_image_folder = train_image_folder
valid_annot_folder = train_image_folder
if FINE_TUNE:
BATCH_SIZE = 4
if TEST_RUN:
EPOCHS = 1
else:
EPOCHS = 100
model = get_yolo_model(IMAGE_W,
IMAGE_H,
num_class=1,
headtrainable=True,
trainable=True)
model.load_weights(your_weights)
else:
BATCH_SIZE = 32
EPOCHS = 500
model = get_yolo_model(IMAGE_W,
IMAGE_H,
num_class=1,
headtrainable=True)
model.load_weights(generic_weights, by_name=True)
### read saved pickle of parsed annotations
with open(train_image_folder + list_of_train_files, 'r') as fp:
all_imgs = yaml.load(fp)
print('Reading YaML file finished. Time to luck and load!\n')
num_ims = len(all_imgs)
indexes = np.arange(num_ims)
random.shuffle(indexes)
num_val = 0 #num_ims//10
#valid_imgs = list(itemgetter(*indexes[:num_val].tolist())(all_imgs))
train_imgs = list(itemgetter(*indexes[num_val:].tolist())(all_imgs))
train_batch = BatchGenerator(instances=train_imgs,
labels=LABELS,
batch_size=BATCH_SIZE,
shuffle=True,
jitter=0.0,
im_dir=train_image_folder)
#valid_batch = BatchGenerator(valid_imgs, generator_config, norm=normalize, jitter=False)
def yolo_loss(y_true, y_pred):
# compute grid factor and net factor
grid_h = tf.shape(y_true)[1]
grid_w = tf.shape(y_true)[2]
grid_factor = tf.reshape(tf.cast([grid_w, grid_h], tf.float32),
[1, 1, 1, 1, 2])
net_h = IMAGE_H / grid_h
net_w = IMAGE_W / grid_w
net_factor = tf.reshape(tf.cast([net_w, net_h], tf.float32),
[1, 1, 1, 1, 2])
pred_box_xy = y_pred[..., 0:2] # t_wh
pred_box_wh = tf.log(y_pred[..., 2:4]) # t_wh
pred_box_conf = tf.expand_dims(y_pred[..., 4], 4)
pred_box_class = y_pred[..., 5:] # adjust class probabilities
# initialize the masks
object_mask = tf.expand_dims(y_true[..., 4], 4)
true_box_xy = y_true[..., 0:2] # (sigma(t_xy) + c_xy)
true_box_wh = tf.where(y_true[..., 2:4] > 0,
tf.log(tf.cast(y_true[..., 2:4], tf.float32)),
y_true[..., 2:4])
true_box_conf = tf.expand_dims(y_true[..., 4], 4)
true_box_class = y_true[..., 5:]
xy_delta = COORD_SCALE * object_mask * (pred_box_xy - true_box_xy
) #/net_factor #* xywh_scale
wh_delta = COORD_SCALE * object_mask * (pred_box_wh - true_box_wh
) #/ net_factor #* xywh_scale
obj_delta = OBJECT_SCALE * object_mask * (pred_box_conf -
true_box_conf)
no_obj_delta = NO_OBJECT_SCALE * (1 - object_mask) * pred_box_conf
class_delta = CLASS_SCALE * object_mask * (pred_box_class -
true_box_class)
loss_xy = tf.reduce_sum(tf.square(xy_delta), list(range(1, 5)))
loss_wh = tf.reduce_sum(tf.square(wh_delta), list(range(1, 5)))
loss_obj = tf.reduce_sum(tf.square(obj_delta), list(range(1, 5)))
lossnobj = tf.reduce_sum(tf.square(no_obj_delta), list(range(1, 5)))
loss_cls = tf.reduce_sum(tf.square(class_delta), list(range(1, 5)))
loss = loss_xy + loss_wh + loss_obj + lossnobj + loss_cls
return loss
print('Prepared bathes now we will load weights')
wt_file = your_weights
optimizer = Adam(lr=0.5e-4,
beta_1=0.9,
beta_2=0.999,
epsilon=1e-08,
decay=0.0)
model.compile(loss=yolo_loss, optimizer=optimizer)
early_stop = EarlyStopping(monitor='loss',
min_delta=0.001,
patience=5,
mode='min',
verbose=1)
checkpoint = ModelCheckpoint(wt_file,
monitor='loss',
verbose=1,
save_best_only=True,
mode='min',
period=1)
print('Training starts.')
start = time.time()
model.fit_generator(
generator=train_batch,
steps_per_epoch=len(train_batch),
epochs=EPOCHS,
verbose=1,
# validation_data = valid_batch,
# validation_steps = len(valid_batch),
callbacks=[checkpoint, early_stop], #, tensorboard],
max_queue_size=3)
model.save_weights(trained_weights)
end = time.time()
print('Training took ' + str(end - start) + ' seconds')
print('Weights saved to ' + trained_weights)
print("Finished! :o)")
train_imgs = list(itemgetter(*indexes[:].tolist())(all_imgs))
def normalize(image):
image = image / 255.
return image
train_batch = BatchGenerator(
instances=train_imgs,
anchors=ANCHORS,
labels=LABELS,
downsample=
32, # ratio between network input's size and network output's size, 32 for YOLOv3
max_box_per_image=1000,
batch_size=BATCH_SIZE,
min_net_size=IMAGE_H,
max_net_size=IMAGE_H,
shuffle=False,
jitter=0.0,
norm=normalize)
if FINE_TUNE:
optimizer = Adam(lr=0.5e-6,
beta_1=0.9,
beta_2=0.999,
epsilon=1e-08,
decay=0.0)
EPOCHS = 20
else:
def _main_(args):
config_path = args.conf
with open(config_path, encoding='UTF-8') as config_buffer:
config = json.loads(config_buffer.read())
###############################
# Parse the annotations
###############################
train_ints, valid_ints, labels, max_box_per_image = create_training_instances(
config['train']['train_annot_folder'],
config['train']['train_image_folder'],
config['train']['cache_name'],
config['valid']['valid_annot_folder'],
config['valid']['valid_image_folder'],
config['valid']['cache_name'],
config['model']['labels']
)
print('\n[INFO] Training on: \t' + str(labels) + '\n')
###############################
# Create the generators
###############################
train_generator = BatchGenerator(
instances = train_ints,
anchors = config['model']['anchors'],
labels = labels,
downsample = 32, # ratio between network input's size and network output's size, 32 for YOLOv3
max_box_per_image = max_box_per_image,
batch_size = config['train']['batch_size'],
min_net_size = config['model']['min_input_size'],
max_net_size = config['model']['max_input_size'],
shuffle = True,
jitter = 0.3,
norm = normalize
)
valid_generator = BatchGenerator(
instances = valid_ints,
anchors = config['model']['anchors'],
labels = labels,
downsample = 32, # ratio between network input's size and network output's size, 32 for YOLOv3
max_box_per_image = max_box_per_image,
batch_size = config['train']['batch_size'],
min_net_size = config['model']['min_input_size'],
max_net_size = config['model']['max_input_size'],
shuffle = True,
jitter = 0.0,
norm = normalize
)
print("[INFO] Creating Model...")
###############################
# Create the model
###############################
if os.path.exists(config['train']['saved_weights_name']):
config['train']['warmup_epochs'] = 0
warmup_batches = config['train']['warmup_epochs'] * (config['train']['train_times']*len(train_generator))
os.environ['CUDA_VISIBLE_DEVICES'] = config['train']['gpus']
multi_gpu = len(config['train']['gpus'].split(','))
train_model, infer_model = create_model(
config=config,
max_box_per_image=max_box_per_image,
warmup_batches= warmup_batches,
multi_gpu=multi_gpu,
saved_weights_name=config['train']['saved_weights_name'],
lr=config['train']['learning_rate']
)
###############################
# Kick off the training
###############################
callbacks = create_callbacks(config['train']['saved_weights_name'],
config['train']['tensorboard_dir'],
infer_model,
valid_generator,
labels,
config_path.split('_')[0])
print("[INFO] Training Model...")
train_model.fit_generator(
generator = train_generator,
steps_per_epoch = len(train_generator) * config['train']['train_times'],
epochs = config['train']['nb_epochs'] + config['train']['warmup_epochs'],
# validation_data = valid_generator,
# validation_steps = len(train_generator) / config['train']['batch_size'],
verbose = 2 if config['train']['debug'] else 1,
callbacks = callbacks,
workers = 4,
max_queue_size = 8
)
print("[INFO] Saving Model...")
print("[INFO] Start Evalutating Model...")
# make a GPU version of infer_model for evaluation
if multi_gpu > 1:
infer_model = load_model(config['train']['saved_weights_name'])
def main():
'Main'
from argparse import ArgumentParser
import os
# available architectures
models_list = [
'vgg16',
'vgg19',
'inceptionv3',
'resnet50',
'custom',
'xception',
'inceptionresnet',
'mobilenet',
'densenet121',
'densenet169',
'densenet201',
'nasnet',
'mobilenetv2'
]
# available optimizers
optimizers_list = ['sgd', 'adam']
losses_list = [
'categorical_crossentropy',
'sparse_categorical_crossentropy',
'binary_crossentropy',
'mean_squared_error',
'mean_absolute_error',
'mean_absolute_percentage_error',
'mean_squared_logarithmic_error',
'squared_hinge',
'hinge',
'categorical_hinge',
'logcosh',
'kullback_leibler_divergence',
'poisson',
'cosine_proximity'
]
# print these names for loss functions
losses_dict = {
'mean_squared_error': 'MSE',
'mean_absolute_error': 'MAE',
'mean_absolute_percentage_error': 'MAPE',
'mean_squared_logarithmic_error': 'MSLE',
'squared_hinge': 'Squared Hinge',
'hinge': 'Hinge',
'categorical_hinge': 'Categorical Hinge',
'logcosh': 'Log-Cosh',
'categorical_crossentropy': 'Categorial Cross-entropy',
'sparse_categorical_crossentropy': 'Sparse Categorical Cross-entropy',
'binary_crossentropy': 'Binary Cross-entropy',
'kullback_leibler_divergence': 'Kullback-Leibler Divergence',
'poisson': 'Poisson',
'cosine_proximity': 'Cosine Proximity'
}
parser = ArgumentParser()
parser.add_argument('model', help='which model to use',
type=str, choices=models_list)
parser.add_argument('path', help='path to data', type=str)
parser.add_argument('--loadfrom', help='load previous model', type=str)
parser.add_argument(
'-e', '--epochs', help='epochs to train for', type=int, default=30)
parser.add_argument(
'-b', '--batch', help='training batch size', type=int, default=8)
parser.add_argument('-o', '--optimizer', help='optimizer to use',
type=str, choices=optimizers_list, default='sgd')
parser.add_argument(
'-s', '--split', help='test split size', default=0.2, type=float)
parser.add_argument('-t', '--testset', help='path to test data', type=str)
parser.add_argument('--loss', help='loss function to use', type=str,
choices=losses_list, default='categorical_crossentropy')
parser.add_argument('--nogpu', help='disable GPU',
action='store_true', dest='no_gpu')
parser.add_argument('--usemp', help='enable multiprocessing for sequences',
action='store_true', dest='use_mp')
parser.add_argument(
'--pretrained', help='load pre-trained weights', action='store_true')
parser.add_argument('--output', help='output file', type=str)
parser.add_argument('--extsum', help='print extended summary',
action='store_true', dest='print_extsum')
parser.add_argument('--sum', help='print summary',
action='store_true', dest='print_sum')
parser.add_argument('--json', help='save model as JSON file', type=str)
parser.add_argument('--log', help='test log filename',
type=str, default='tests_log.log')
parser.add_argument(
'--shape', help='input shape in (height:width:depth) format', type=str)
parser.add_argument(
'--dropout', help='dropout probability (default=0)', type=float)
parser.add_argument('--pfldir', help='put .pfl files here',
type=str, default='.', dest='pfldir')
parser.add_argument('--decay', help='weight decay',
default=0.005, type=float, dest='weight_decay')
parser.add_argument('-K', help='apply kernel regularization',
action='store_true', dest='regularize_kernel')
parser.add_argument('-B', help='apply bias regularization',
action='store_true', dest='regularize_bias')
parser.add_argument('-A', help='apply activity regularization',
action='store_true', dest='regularize_activity')
parser.add_argument(
'-a', '--augment', help='apply perform data augmentation', action='store_true')
parser.add_argument(
'--seed', help='random seed for train-test split', type=int, default=7)
args = parser.parse_args()
from keras.callbacks import Callback
if args.pfldir:
os.makedirs(args.pfldir, exist_ok=True)
if args.output:
os.makedirs(args.output, exist_ok=True)
class PerformanceHistory(Callback):
def __init__(self, output_file: str):
super().__init__()
self.output_file = open(output_file, 'wt')
self.csv_file = csv.writer(self.output_file)
self.csv_file.writerow(
['ACCURACY', 'LOSS', 'VALIDATION ACCURACY', 'VALIDATION LOSS'])
def on_epoch_end(self, batch, logs={}):
self.csv_file.writerow([logs.get('accuracy'), logs.get(
'loss'), logs.get('val_accuracy'), logs.get('val_loss')])
self.output_file.flush()
def __del__(self):
self.output_file.close()
if args.no_gpu:
os.environ['CUDA_DEVICE_ORDER'] = 'PCI_BUS_ID'
os.environ['CUDA_VISIBLE_DEVICES'] = ''
image_dim = 224 if args.model in ['vgg16', 'vgg19', 'custom'] else 299
input_shape = (image_dim, image_dim, 3)
if args.shape is not None:
input_shape = [(int(y) if y != '' else 1)
for y in args.shape.split(':')]
import keras.applications as apps
# preprocessing functions dictonary
input_preprocessing = {
'vgg16': apps.vgg16.preprocess_input,
'vgg19': apps.vgg19.preprocess_input,
'inceptionv3': apps.inception_v3.preprocess_input,
'resnet50': apps.resnet50.preprocess_input,
'custom': apps.vgg16.preprocess_input,
'xception': apps.xception.preprocess_input,
'inceptionresnet': apps.inception_resnet_v2.preprocess_input,
'mobilenet': apps.mobilenet.preprocess_input,
'densenet121': apps.densenet.preprocess_input,
'densenet169': apps.densenet.preprocess_input,
'densenet201': apps.densenet.preprocess_input,
'nasnet': apps.nasnet.preprocess_input,
'mobilenetv2': apps.mobilenet_v2.preprocess_input
}
from keras.layers import Dropout
from keras.regularizers import l2
from keras.models import load_model
from keras import Model
from optimizers import getOptimizer
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelBinarizer
from generator import AugmentedBatchGenerator, BatchGenerator
from extsum import extended_summary
import numpy as np
import datetime as dt
import pickle
import csv
import subprocess
from random import shuffle, seed
# load default specified dataset
data_path = os.path.abspath(args.path)
X_raw = []
y_raw = []
for d in os.listdir(data_path):
for f in os.listdir(data_path + '/' + d):
X_raw.append('/'.join([data_path, d, f]))
y_raw.append(d)
lb = LabelBinarizer()
lb.fit(y_raw)
seed(args.seed)
if args.testset:
# if a test set was specified, load it
print(f'Using data at {args.testset} as test set.')
# shuffle training data
training_shuffled = list(zip(X_raw, y_raw))
shuffle(training_shuffled)
X_data, y_data = zip(*training_shuffled)
X_data, y_data = np.asarray(X_data), lb.transform(y_data)
X_train, y_train = X_data, y_data
data_path = os.path.abspath(args.testset)
X_raw = []
y_raw = []
for d in os.listdir(data_path):
for f in os.listdir(data_path + '/' + d):
X_raw.append('/'.join([data_path, d, f]))
y_raw.append(d)
# shuffle test
test_shuffled = list(zip(X_raw, y_raw))
shuffle(test_shuffled)
X_raw, y_raw = zip(*test_shuffled)
X_test, y_test = np.asarray(X_raw), lb.transform(y_raw)
else:
# otherwise split default dataset
print(f'Using {args.split} of the provided dataset as test set.')
X_data, y_data = np.asarray(X_raw), lb.transform(y_raw)
X_train, X_test, y_train, y_test = train_test_split(
X_data, y_data, test_size=args.split, random_state=args.seed)
del X_raw
del y_raw
n_classes = y_data.shape[1]
models_dict = {
'xception': apps.Xception,
'vgg16': apps.VGG16,
'vgg19': apps.VGG19,
'resnet50': apps.ResNet50,
'inceptionv3': apps.InceptionV3,
'inceptionresnet': apps.InceptionResNetV2,
'mobilenet': apps.MobileNet,
'mobilenetv2': apps.MobileNetV2,
'densenet121': apps.DenseNet121,
'densenet169': apps.DenseNet169,
'densenet201': apps.DenseNet201,
'nasnet': apps.NASNetLarge
}
# load vanilla model with specified parameters
model = models_dict[args.model](
classes=n_classes, input_shape=input_shape, weights='imagenet' if args.pretrained else None)
if args.dropout is not None:
print('Adding weight decay')
# insert dropout layer and regularization
preds = model.layers[-1]
dp = Dropout(args.dropout)(model.layers[-2].output)
preds = preds(dp)
model = Model(inputs=model.inputs, outputs=preds)
for layer in model.layers:
if args.regularize_kernel:
layer.kernel_regularizer = l2(args.weight_decay)
if args.regularize_bias:
layer.bias_regularizer = l2(args.weight_decay)
if args.regularize_activity:
layer.activity_regularizer = l2(args.weight_decay)
opt = getOptimizer(args.optimizer)
model.compile(loss=args.loss, optimizer=opt, metrics=['accuracy'])
if args.loadfrom:
print('Loading', args.loadfrom)
model = load_model(os.path.abspath(args.loadfrom))
# iteratively rename performance file
pfldir = os.path.abspath(args.pfldir)
performance_file = os.path.join(
pfldir, f'{args.model}_b{args.batch}_e{args.epochs}.pfl')
fnum = 1
while os.path.isfile(performance_file):
performance_file = os.path.join(
pfldir, f'{args.model}_b{args.batch}_e{args.epochs}_{fnum}.pfl')
fnum += 1
os.makedirs(pfldir, exist_ok=True)
if args.print_extsum:
extended_summary(model)
elif args.print_sum:
model.summary()
perf_log = PerformanceHistory(performance_file)
# print test parameters to screen
print('\n{:<20}{}'.format('Model', args.model))
print('{:<20}{}'.format('Input shape', input_shape))
print('{:<20}{}'.format('Epochs', args.epochs))
print('{:<20}{}'.format('Batch size', args.batch))
print('{:<20}{}'.format('Optimizer', type(opt).__name__))
print('{:<20}{}'.format('Optimizer params',
paramDictFormat(opt.get_config())))
print('{:<20}{}'.format('Loss', args.loss))
print('{:<20}{}'.format('Multiprocessing', 'On' if args.use_mp else 'Off'))
print('{:<20}{}'.format('Performance log', performance_file))
print('{:<20}{}'.format('Test log', args.log))
print('{:<20}{}'.format('Dataset', args.path))
reg = []
if args.regularize_kernel:
reg.append('kernel')
if args.regularize_activity:
reg.append('activity')
if args.regularize_bias:
reg.append('bias')
print('{:<20}{}\n'.format('Regularization',
'None' if not reg else ', '.join(reg)))
opt = getOptimizer(args.optimizer)
model.compile(loss=args.loss, optimizer=opt, metrics=['accuracy'])
# create training batch generator
if args.augment:
print('Data augmentation enabled.')
train_gen = AugmentedBatchGenerator(X_train, y_train, args.batch, shape=input_shape, ops=[
input_preprocessing[args.model]], pad=False)
else:
print('Data augmentation disabled.')
train_gen = BatchGenerator(X_train, y_train, args.batch, shape=input_shape, ops=[
input_preprocessing[args.model]], pad=False)
# create testing batch generator
test_gen = BatchGenerator(X_test, y_test, args.batch, shape=input_shape, ops=[
input_preprocessing[args.model]], pad=False)
# train model
train_start = dt.datetime.now()
model.fit_generator(train_gen, epochs=args.epochs, use_multiprocessing=args.use_mp,
validation_data=test_gen, callbacks=[perf_log])
train_end = dt.datetime.now()
# evaluate final model on train set
train_score = model.evaluate_generator(train_gen)
print('Train loss:', train_score[0])
print('Train accuracy:', train_score[1])
# evaluate final model on test set
test_score = model.evaluate_generator(test_gen)
print('Test loss:', test_score[0])
print('Test accuracy:', test_score[1])
# update tests log with current test data
date_format = '{:%Y-%m-%d %H:%M}'
log_format = '{:<20}{:<20}{:<20}{:<10}{:<10}{:<15}{:<15.5}{:<15.5}{:<15.5}{:<15.5}{:<30}{:<30}{:<70}{:<15}{:<15}{:<15}{:<15.5}{:<15.5}\n'
header_format = '{:<20}{:<20}{:<20}{:<10}{:<10}{:<15}{:<15}{:<15}{:<15}{:<15}{:<30}{:<30}{:<70}{:<15}{:<15}{:<15}{:<15}{:<15}\n'
with open(args.log, 'a+t') as test_log:
if test_log.tell() <= 0:
test_log.write(header_format.format(
'BEGIN', 'END', 'ARCHITECTURE', 'BATCH', 'EPOCHS', 'OPTIMIZER', 'TRAIN LOSS', 'TRAIN ACC', 'TEST LOSS', 'TEST ACC', 'DATA FOLDER', 'LOSS FUNCTION', 'OPTIMIZER PARAMS',
'KERNEL REG', 'BIAS REG', 'ACTIV. REG', 'DECAY', 'DROPOUT'))
start_str = date_format.format(train_start)
end_str = date_format.format(train_end)
data_folder = args.path.split('/')[-1 if args.path[-1] != '/' else -2]
test_log.write(log_format.format(start_str, end_str, args.model.upper(), args.batch, args.epochs, args.optimizer.upper(), train_score[0], train_score[1],
test_score[0], test_score[1], data_folder, losses_dict[args.loss], paramDictFormat(
opt.get_config()),
'YES' if args.regularize_kernel else 'NO',
'YES' if args.regularize_bias else 'NO',
'YES' if args.regularize_activity else 'NO',
args.weight_decay,
args.dropout if args.dropout else 0.0))
# save the model and class file if an output filename was specified
if args.output is not None:
print(f'Saving model as {args.output}.h5')
os.makedirs('/'.join(args.output.split('/')[:-1]), exist_ok=True)
model.save(f'{args.output}.h5')
with open(f'{args.output}.bin', 'wb') as fout:
pickle.dump((args.model, lb), fout)
subprocess.run(['notify-send', 'Entrenamiento completado',
f'Se ha completado el entrenamiento del modelo {args.model}.'], check=False)
num_ims = len(all_imgs)
indexes = np.arange(num_ims)
#random.shuffle(indexes)
num_val = 0 #num_ims//10
#valid_imgs = list(itemgetter(*indexes[:num_val].tolist())(all_imgs))
train_imgs = list(itemgetter(*indexes[num_val:].tolist())(all_imgs))
train_batch = BatchGenerator(
instances=train_imgs,
labels=LABELS,
downsample=
32, # ratio between network input's size and network output's size, 32 for YOLOv3
batch_size=BATCH_SIZE,
min_net_size=IMAGE_H,
max_net_size=IMAGE_H,
shuffle=False,
jitter=0.0,
im_dir=train_image_folder)
#sys.exit('bye')
#train_batch = BatchGenerator(train_imgs, generator_config, norm=normalize, jitter=False)
#valid_batch = BatchGenerator(valid_imgs, generator_config, norm=normalize, jitter=False)
# In[104]:
# **Setup a few callbacks and start the training**
# In[105]:
def _main_(args):
config_path = args.conf
with open(config_path) as config_buffer:
config = json.loads(config_buffer.read())
###############################
# Parse the annotations
###############################
train_ints, valid_ints, labels, max_box_per_image = create_training_instances(
config['train']['train_annot_folder'],
config['train']['train_image_folder'], config['train']['cache_name'],
config['valid']['valid_annot_folder'],
config['valid']['valid_image_folder'], config['valid']['cache_name'],
config['model']['labels'])
print('\nTraining on: \t' + str(labels) + '\n')
###############################
# Create the generators
###############################
train_generator = BatchGenerator(
instances=train_ints,
anchors=config['model']['anchors'],
labels=labels,
downsample=
32, # ratio between network input's size and network output's size, 32 for YOLOv3
max_box_per_image=max_box_per_image,
batch_size=config['train']['batch_size'],
min_net_size=config['model']['min_input_size'],
max_net_size=config['model']['max_input_size'],
shuffle=True,
jitter=0.3,
norm=normalize)
valid_generator = BatchGenerator(
instances=valid_ints,
anchors=config['model']['anchors'],
labels=labels,
downsample=
32, # ratio between network input's size and network output's size, 32 for YOLOv3
max_box_per_image=max_box_per_image,
batch_size=config['train']['batch_size'],
min_net_size=config['model']['min_input_size'],
max_net_size=config['model']['max_input_size'],
shuffle=True,
jitter=0.0,
norm=normalize)
###############################
# Create the model
###############################
if os.path.exists(config['train']['saved_weights_name']):
config['train']['warmup_epochs'] = 0
warmup_batches = config['train']['warmup_epochs'] * (
config['train']['train_times'] * len(train_generator))
os.environ['CUDA_VISIBLE_DEVICES'] = config['train']['gpus']
multi_gpu = len(config['train']['gpus'].split(','))
train_model, infer_model = create_model(
nb_class=len(labels),
anchors=config['model']['anchors'],
max_box_per_image=max_box_per_image,
max_grid=[
config['model']['max_input_size'],
config['model']['max_input_size']
],
batch_size=config['train']['batch_size'],
warmup_batches=warmup_batches,
ignore_thresh=config['train']['ignore_thresh'],
multi_gpu=multi_gpu,
saved_weights_name=config['train']['saved_weights_name'],
lr=config['train']['learning_rate'],
grid_scales=config['train']['grid_scales'],
obj_scale=config['train']['obj_scale'],
noobj_scale=config['train']['noobj_scale'],
xywh_scale=config['train']['xywh_scale'],
class_scale=config['train']['class_scale'],
)
###############################
# Kick off the training
###############################
callbacks = create_callbacks(config['train']['saved_weights_name'],
config['train']['tensorboard_dir'],
infer_model)
train_model.fit_generator(
generator=train_generator,
steps_per_epoch=len(train_generator) * config['train']['train_times'],
epochs=config['train']['nb_epochs'] + config['train']['warmup_epochs'],
verbose=2 if config['train']['debug'] else 1,
callbacks=callbacks,
workers=4,
max_queue_size=8)
# make a GPU version of infer_model for evaluation
if multi_gpu > 1:
infer_model = load_model(config['train']['saved_weights_name'])
###############################
# Run the evaluation
###############################
# compute mAP for all the classes
average_precisions = evaluate(infer_model, valid_generator)
# print the score
for label, average_precision in average_precisions.items():
print(labels[label] + ': {:.4f}'.format(average_precision))
print('mAP: {:.4f}'.format(
sum(average_precisions.values()) / len(average_precisions)))
def _main_(args):
config_path = args.conf
with open(config_path) as config_buffer:
config = json.loads(config_buffer.read())
###############################
# Parse the annotations
###############################
train_ints, valid_ints, labels, max_box_per_image = create_training_instances(
config['train']['train_annot_folder'],
config['train']['train_image_folder'], config['train']['cache_name'],
config['valid']['valid_annot_folder'],
config['valid']['valid_image_folder'], config['valid']['cache_name'],
config['model']['labels'])
print('\nTraining on: \t' + str(labels) + '\n')
###############################
# Create the generators
###############################
train_generator = BatchGenerator(
instances=train_ints,
anchors=config['model']['anchors'],
labels=labels,
downsample=
32, # ratio between network input's size and network output's size, 32 for YOLOv3
max_box_per_image=max_box_per_image,
batch_size=config['train']['batch_size'],
min_net_size=config['model']['min_input_size'],
max_net_size=config['model']['max_input_size'],
shuffle=True,
jitter=0.3,
norm=normalize)
valid_generator = BatchGenerator(
instances=valid_ints,
anchors=config['model']['anchors'],
labels=labels,
downsample=
32, # ratio between network input's size and network output's size, 32 for YOLOv3
max_box_per_image=max_box_per_image,
batch_size=config['train']['batch_size'],
min_net_size=config['model']['min_input_size'],
max_net_size=config['model']['max_input_size'],
shuffle=True,
jitter=0.0,
norm=normalize)
###############################
# Create the model
###############################
if os.path.exists(config['train']['saved_weights_name']):
config['train']['warmup_epochs'] = 0
warmup_batches = config['train']['warmup_epochs'] * (
config['train']['train_times'] * len(train_generator))
os.environ['CUDA_VISIBLE_DEVICES'] = config['train']['gpus']
multi_gpu = len(config['train']['gpus'].split(','))
print('multi_gpu:' + str(multi_gpu))
train_model, infer_model = create_model(
nb_class=len(labels),
anchors=config['model']['anchors'],
max_box_per_image=max_box_per_image,
max_grid=[
config['model']['max_input_size'],
config['model']['max_input_size']
],
batch_size=config['train']['batch_size'],
warmup_batches=warmup_batches,
ignore_thresh=config['train']['ignore_thresh'],
multi_gpu=multi_gpu,
saved_weights_name=config['train']['saved_weights_name'],
lr=config['train']['learning_rate'],
grid_scales=config['train']['grid_scales'],
obj_scale=config['train']['obj_scale'],
noobj_scale=config['train']['noobj_scale'],
xywh_scale=config['train']['xywh_scale'],
class_scale=config['train']['class_scale'],
backend=config['model']['backend'])
###############################
# Kick off the training
###############################
callbacks = create_callbacks(config['train']['saved_weights_name'],
config['train']['tensorboard_dir'],
infer_model)
train_model.fit(
x=train_generator,
validation_data=valid_generator,
steps_per_epoch=len(train_generator) * config['train']['train_times'],
epochs=config['train']['nb_epochs'] + config['train']['warmup_epochs'],
verbose=2 if config['train']['debug'] else 1,
workers=4,
max_queue_size=8,
callbacks=callbacks)
train_model.load_weights(config['train']['saved_weights_name'])
infer_model.save(config['train']['saved_weights_name'])
###############################
# Run the evaluation
###############################
# compute mAP for all the classes
average_precisions = evaluate(infer_model, valid_generator)
# print the score
total_instances = []
precisions = []
for label, (average_precision,
num_annotations) in average_precisions.items():
print('{:.0f} instances of class'.format(num_annotations),
labels[label],
'with average precision: {:.4f}'.format(average_precision))
total_instances.append(num_annotations)
precisions.append(average_precision)
if sum(total_instances) == 0:
print('No test instances found.')
return
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)))
