def main(_):
if FLAGS.binary_img:
tfrecord_name = './data/ms1m_bin.tfrecord'
else:
tfrecord_name = './data/ms1m.tfrecord'
train_dataset = load_tfrecord_dataset(tfrecord_name,
FLAGS.batch_size,
binary_img=FLAGS.binary_img,
is_ccrop=FLAGS.is_ccrop)
num_samples = 100
start_time = time.time()
for idx, parsed_record in enumerate(train_dataset.take(num_samples)):
(x_train, _), y_train = parsed_record
print("{} x_train: {}, y_train: {}".format(idx, x_train.shape,
y_train.shape))
if FLAGS.visualization:
recon_img = np.array(x_train[0].numpy() * 255, 'uint8')
cv2.imshow('img', cv2.cvtColor(recon_img, cv2.COLOR_RGB2BGR))
if cv2.waitKey(0) == 113:
exit()
print("data fps: {:.2f}".format(num_samples / (time.time() - start_time)))
def load_dataset(path, size, batch, shuffle=True, buffer_size=10240):
"""load dataset"""
dataset = load_tfrecord_dataset(tfrecord_name=path,
batch_size=batch,
size=size,
shuffle=shuffle,
using_bin=True,
using_flip=True,
using_rot=True,
buffer_size=buffer_size)
return dataset
def load_dataset(cfg, key, shuffle=True, buffer_size=10240):
"""load dataset"""
dataset_cfg = cfg[key]
logging.info("load {} from {}".format(key, dataset_cfg['path']))
dataset = load_tfrecord_dataset(tfrecord_name=dataset_cfg['path'],
batch_size=cfg['batch_size'],
gt_size=cfg['gt_size'],
scale=cfg['scale'],
shuffle=shuffle,
using_bin=dataset_cfg['using_bin'],
using_flip=dataset_cfg['using_flip'],
using_rot=dataset_cfg['using_rot'],
buffer_size=buffer_size)
return dataset
def main(_):
if FLAGS.using_bin:
train_dataset = load_tfrecord_dataset(
'./data/DIV2K800_sub_bin.tfrecord', 16, 128, 4,
using_bin=True, using_flip=True, using_rot=False, buffer_size=10)
else:
train_dataset = load_tfrecord_dataset(
'./data/DIV2K800_sub.tfrecord', 16, 128, 4,
using_bin=False, using_flip=True, using_rot=False, buffer_size=10)
num_samples = 100
start_time = time.time()
for idx, (inputs, labels) in enumerate(train_dataset.take(num_samples)):
print("{} inputs:".format(idx), inputs.shape, "outputs:", labels.shape)
if FLAGS.visualization:
cv2.imshow('inputs', cv2.cvtColor(inputs[0].numpy(),cv2.COLOR_RGB2BGR))
cv2.imshow('labels', cv2.cvtColor(labels[0].numpy(),cv2.COLOR_RGB2BGR))
if cv2.waitKey(0) == ord('q'):
exit()
print("data fps: {:.2f}".format(num_samples / (time.time() - start_time)))
def load_dataset(cfg, priors, shuffle=True, buffer_size=10240):
"""load dataset"""
logging.info("load dataset from {}".format(cfg['dataset_path']))
dataset = load_tfrecord_dataset(tfrecord_name=cfg['dataset_path'],
batch_size=cfg['batch_size'],
img_dim=cfg['input_size'],
using_bin=cfg['using_bin'],
using_flip=cfg['using_flip'],
using_distort=cfg['using_distort'],
using_encoding=True,
priors=priors,
match_thresh=cfg['match_thresh'],
ignore_thresh=cfg['ignore_thresh'],
variances=cfg['variances'],
shuffle=shuffle,
buffer_size=buffer_size)
return dataset
def load_dataset(cfg, priors, shuffle=True, buffer_size=10240):
"""load dataset"""
logging.info("load dataset from {}".format(cfg["dataset_path"]))
dataset = load_tfrecord_dataset(
tfrecord_name=cfg["dataset_path"],
batch_size=cfg["batch_size"],
img_dim=cfg["input_size"],
using_bin=cfg["using_bin"],
using_flip=cfg["using_flip"],
using_distort=cfg["using_distort"],
using_encoding=True,
priors=priors,
match_thresh=cfg["match_thresh"],
ignore_thresh=cfg["ignore_thresh"],
variances=cfg["variances"],
shuffle=shuffle,
buffer_size=buffer_size,
)
return dataset
def load_dataset(cfg, priors, split, hvd):
"""load dataset"""
logging.info("load dataset from {}".format(cfg['dataset_root']))
if split is 'train':
batch_size = cfg['batch_size']
shuffle = True
using_flip = cfg['using_flip']
using_distort = cfg['using_distort']
using_encoding = True
buffer_size = 2000
number_cycles = cfg['number_cycles']
threads = tf.data.experimental.AUTOTUNE
else:
batch_size = 1
shuffle = False
using_flip = False
using_distort = False
using_encoding = False
buffer_size = 2000
number_cycles = 1
threads = tf.data.experimental.AUTOTUNE
dataset = load_tfrecord_dataset(dataset_root=cfg['dataset_root'],
split=split,
threads=threads,
number_cycles=number_cycles,
batch_size=batch_size,
hvd=hvd,
img_dim=cfg['input_size'],
using_bin=cfg['using_bin'],
using_flip=using_flip,
using_distort=using_distort,
using_encoding=using_encoding,
priors=priors,
match_thresh=cfg['match_thresh'],
ignore_thresh=cfg['ignore_thresh'],
variances=cfg['variances'],
shuffle=shuffle,
buffer_size=buffer_size)
return dataset
def main(_):
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
os.environ['CUDA_VISIBLE_DEVICES'] = FLAGS.gpu
logger = tf.get_logger()
logger.disabled = True
logger.setLevel(logging.FATAL)
set_memory_growth()
cfg = load_yaml(FLAGS.cfg_path)
model = ArcFaceModel(size=cfg['input_size'],
backbone_type=cfg['backbone_type'],
num_classes=cfg['num_classes'],
head_type=cfg['head_type'],
embd_shape=cfg['embd_shape'],
w_decay=cfg['w_decay'],
training=True)
model.summary(line_length=80)
if cfg['train_dataset']:
logging.info("load ms1m dataset.")
dataset_len = cfg['num_samples']
steps_per_epoch = dataset_len // cfg['batch_size']
train_dataset = dataset.load_tfrecord_dataset(cfg['train_dataset'],
cfg['batch_size'],
cfg['binary_img'],
is_ccrop=cfg['is_ccrop'])
else:
logging.info("load fake dataset.")
dataset_len = 1
steps_per_epoch = 1
train_dataset = dataset.load_fake_dataset(cfg['input_size'])
learning_rate = tf.constant(cfg['base_lr'])
optimizer = tf.keras.optimizers.SGD(learning_rate=learning_rate,
momentum=0.9,
nesterov=True)
loss_fn = SoftmaxLoss()
ckpt_path = tf.train.latest_checkpoint('./checkpoints/' + cfg['sub_name'])
if ckpt_path is not None:
print("[*] load ckpt from {}".format(ckpt_path))
model.load_weights(ckpt_path)
epochs, steps = get_ckpt_inf(ckpt_path, steps_per_epoch)
else:
print("[*] training from scratch.")
epochs, steps = 1, 1
if FLAGS.mode == 'eager_tf':
# Eager mode is great for debugging
# Non eager graph mode is recommended for real training
summary_writer = tf.summary.create_file_writer('./logs/' +
cfg['sub_name'])
train_dataset = iter(train_dataset)
while epochs <= cfg['epochs']:
inputs, labels = next(train_dataset)
with tf.GradientTape() as tape:
logist = model(inputs, training=True)
reg_loss = tf.reduce_sum(model.losses)
pred_loss = loss_fn(labels, logist)
total_loss = pred_loss + reg_loss
grads = tape.gradient(total_loss, model.trainable_variables)
optimizer.apply_gradients(zip(grads, model.trainable_variables))
if steps % 5 == 0:
verb_str = "Epoch {}/{}: {}/{}, loss={:.2f}, lr={:.4f}"
print(
verb_str.format(epochs, cfg['epochs'],
steps % steps_per_epoch, steps_per_epoch,
total_loss.numpy(), learning_rate.numpy()))
with summary_writer.as_default():
tf.summary.scalar('loss/total loss',
total_loss,
step=steps)
tf.summary.scalar('loss/pred loss', pred_loss, step=steps)
tf.summary.scalar('loss/reg loss', reg_loss, step=steps)
tf.summary.scalar('learning rate',
optimizer.lr,
step=steps)
if steps % cfg['save_steps'] == 0:
print('[*] save ckpt file!')
model.save_weights('checkpoints/{}/e_{}_b_{}.ckpt'.format(
cfg['sub_name'], epochs, steps % steps_per_epoch))
steps += 1
epochs = steps // steps_per_epoch + 1
else:
model.compile(optimizer=optimizer,
loss=loss_fn,
run_eagerly=(FLAGS.mode == 'eager_fit'))
mc_callback = ModelCheckpoint(
'checkpoints/' + cfg['sub_name'] + '/e_{epoch}_b_{batch}.ckpt',
save_freq=cfg['save_steps'] * cfg['batch_size'],
verbose=1,
save_weights_only=True)
tb_callback = TensorBoard(log_dir='logs/',
update_freq=cfg['batch_size'] * 5,
profile_batch=0)
tb_callback._total_batches_seen = steps
tb_callback._samples_seen = steps * cfg['batch_size']
callbacks = [mc_callback, tb_callback]
history = model.fit(train_dataset,
epochs=cfg['epochs'],
steps_per_epoch=steps_per_epoch,
callbacks=callbacks,
initial_epoch=epochs - 1)
print("[*] training done!")
def main(_):
set_memory_growth()
cfg = load_yaml(FLAGS.cfg_path)
model = ArcFaceModel(size=cfg['input_size'],
backbone_type=cfg['backbone_type'],
num_classes=cfg['num_classes'],
head_type=cfg['head_type'],
embd_shape=cfg['embd_shape'],
w_decay=cfg['w_decay'],
training=True)
learning_rate = tf.constant(cfg['base_lr'])
optimizer = tf.keras.optimizers.SGD(learning_rate=learning_rate,
momentum=0.9,
nesterov=True)
loss_fn = SoftmaxLoss()
ckpt_path = tf.train.latest_checkpoint('./checkpoints/train_' +
cfg['sub_name'])
if ckpt_path is not None:
print("[*] load ckpt from {}".format(ckpt_path))
model.load_weights(ckpt_path)
else:
print("[*] training from scratch.")
model.compile(optimizer=optimizer, loss=loss_fn)
# resnet_model = tf.keras.Model(inputs=model.get_layer('resnet50').input,
# outputs=model.get_layer('resnet50').output)
# resnet_head = tf.keras.Model(inputs=resnet_model.input,
# outputs=resnet_model.get_layer('conv2_block1_add').output)
# resnet_tail = split(resnet_model, 18, 1000) # conv2_block1_out
# output_model = tf.keras.Model(inputs=model.get_layer('OutputLayer').input,
# outputs=model.get_layer('OutputLayer').output)
# archead = tf.keras.Model(inputs=model.get_layer('ArcHead').input,
# outputs=model.get_layer('ArcHead').output)
temp1 = np.ones((62, 112, 3))
temp2 = np.zeros((50, 112, 3))
masked_img = np.concatenate([temp1, temp2], axis=0).reshape(1, 112, 112, 3)
temp1 = np.ones((1, 18, 28, 256))
temp2 = np.zeros((1, 10, 28, 256))
masked = np.concatenate([temp1, temp2], axis=1)
# inputs = Input((112, 112, 3))
# labels = Input([])
# s = resnet_head(inputs)
# s = tf.keras.layers.Multiply()([s, tf.constant(masked, dtype=tf.float32)])
# s = resnet_tail(s)
# s = output_model(s)
# s = archead([s, labels])
# new_model = Model((inputs, labels), s)
# new_model.summary()
# new_model.compile(optimizer=optimizer, loss=loss_fn)
path_to_data = '/home/anhdq23/Desktop/nguyen/data/AR/test2'
anchor_names = get_gallery_pr2(path_to_data) # From 1 to 100
name_dicts = get_probe_pr2(
path_to_data) # Dictionary: {anchor_name:[name_image, ...]}
augment = ImgAugTransform()
import faiss
if FLAGS.mode == 'eager_tf':
top_left_all = [0.012]
best_acc = 0.8
for epochs in range(cfg['epochs']):
logging.info("Shuffle ms1m dataset.")
dataset_len = cfg['num_samples']
steps_per_epoch = dataset_len // cfg['batch_size']
train_dataset = dataset.load_tfrecord_dataset(
cfg['train_dataset'],
cfg['batch_size'],
cfg['binary_img'],
is_ccrop=cfg['is_ccrop'])
sub_train_dataset = dataset.load_tfrecord_dataset(
cfg['train_dataset'],
cfg['batch_size'],
cfg['binary_img'],
is_ccrop=cfg['is_ccrop'])
for batch, ((x, y), (sub_x, sub_y)) in enumerate(
zip(train_dataset, sub_train_dataset)):
x0_new = np.array(x[0], dtype=np.uint8)
x1_new = np.array(x[1], dtype=np.float32)
for i in np.arange(len(x0_new)):
x0_new[i] = augment(x0_new[i])
temp = np.array(x0_new, dtype=np.float32) / 255.0
temp = np.multiply(temp, masked_img)
sub_x0_new = np.array(sub_x[0], dtype=np.uint8)
sub_x1_new = np.array(sub_x[1], dtype=np.float32)
for i in np.arange(len(sub_x0_new)):
sub_x0_new[i] = augment(sub_x0_new[i])
sub_temp = np.array(sub_x0_new, dtype=np.float32) / 255.0
model.train_on_batch(*((sub_temp, sub_x1_new), sub_x1_new))
loss = model.train_on_batch(*((temp, x1_new), x1_new))
if batch % 50 == 0:
verb_str = "Epoch {}/{}: {}/{}, loss={:.6f}, lr={:.6f}"
print(
verb_str.format(
epochs, cfg['epochs'], batch, steps_per_epoch,
loss, cfg['base_lr'] / (1.0 + cfg['w_decay'] *
(epochs * 45489 + batch))))
if batch % cfg['save_steps'] == 0:
resnet_model = tf.keras.Model(
inputs=model.get_layer('resnet50').input,
outputs=model.get_layer('resnet50').output)
output_model = tf.keras.Model(
inputs=model.get_layer('OutputLayer').input,
outputs=model.get_layer('OutputLayer').output)
database_image_names = []
database_feature_list = []
for anchor_name in anchor_names:
img1 = Image.open(
os.path.join(path_to_data, anchor_name))
img1 = img1.resize((112, 112))
img1 = np.array(img1) / 255.0
img1 = np.multiply(img1, masked_img)
fc1 = resnet_model.predict(
img1.reshape((1, 112, 112, 3)))
fc1 = output_model.predict(fc1)
norm_fc1 = preprocessing.normalize(fc1.reshape(
(1, 512)),
norm='l2',
axis=1)
database_image_names.append(anchor_name)
database_feature_list.append(norm_fc1)
index_flat = faiss.IndexFlatL2(512)
gpu_index_flat = index_flat
gpu_index_flat.add(
np.array(database_feature_list).reshape(
(-1, 512))) # add vectors to the index
count = 0
for key in list(name_dicts.keys()):
for name in name_dicts[key]:
img2 = Image.open(
os.path.join(path_to_data, name)).resize(
(112, 112))
img2 = img2.resize((112, 112))
img2 = np.array(img2) / 255.0
img2 = np.multiply(img2, masked_img)
fc2 = resnet_model.predict(
img2.reshape((1, 112, 112, 3)))
fc2 = output_model.predict(fc2)
norm_fc2 = preprocessing.normalize(fc2.reshape(
(1, 512)),
norm='l2',
axis=1)
D, I = gpu_index_flat.search(
norm_fc2, k=1) # actual search
if name[0:5] == database_image_names[I[0]
[0]][0:5]:
count += 1
acc = count / 600.0
if acc > best_acc:
best_acc = acc
print('[*] save ckpt file!')
model.save_weights(
'checkpoints/{}/e_{}_b_{}.ckpt'.format(
cfg['sub_name'], epochs,
batch % steps_per_epoch))
print("The current acc: {:.6f} ".format(acc))
print("The best acc: {:.6f} ".format(best_acc))
model.save_weights('checkpoints/train_{}/{}.ckpt'.format(
cfg['sub_name'], cfg['sub_name']))
model = ArcFaceModel(size=cfg['input_size'],
backbone_type=cfg['backbone_type'],
num_classes=cfg['num_classes'],
head_type=cfg['head_type'],
embd_shape=cfg['embd_shape'],
w_decay=cfg['w_decay'],
training=True)
model.summary(line_length=80)
if cfg['train_dataset']:
logging.info("load ms1m dataset.")
dataset_len = cfg['num_samples']
steps_per_epoch = dataset_len // cfg['batch_size']
train_dataset = dataset.load_tfrecord_dataset(
cfg['train_dataset'], cfg['batch_size'], cfg['binary_img'],
is_ccrop=cfg['is_ccrop'])
else:
logging.info("load fake dataset.")
dataset_len = 1
steps_per_epoch = 1
train_dataset = dataset.load_fake_dataset(cfg['input_size'])
learning_rate = tf.constant(cfg['base_lr'])
optimizer = tf.keras.optimizers.SGD(
learning_rate=learning_rate, momentum=0.9, nesterov=True)
loss_fn = SoftmaxLoss()
ckpt_path = tf.train.latest_checkpoint('./checkpoints/' + cfg['sub_name'])
if ckpt_path is not None:
print("[*] load ckpt from {}".format(ckpt_path))
visualization = True # False for time cost estimattion
using_encoding = True # batch size should be 1 when False
variances = [0.1, 0.2]
match_thresh = 0.45
ignore_thresh = 0.3
num_samples = 100
if using_bin:
tfrecord_name = './data/widerface_train_bin.tfrecord'
else:
tfrecord_name = './data/widerface_train.tfrecord'
train_dataset = load_tfrecord_dataset(
tfrecord_name, batch_size, img_dim=640, using_bin=using_bin,
using_flip=True, using_distort=False, using_encoding=using_encoding,
priors=priors, match_thresh=match_thresh, ignore_thresh=ignore_thresh,
variances=variances, shuffle=False)
start_time = time.time()
for idx, (inputs, labels) in enumerate(train_dataset.take(num_samples)):
print("{} inputs:".format(idx), inputs.shape, "labels:", labels.shape)
if not visualization:
continue
img = np.clip(inputs.numpy()[0], 0, 255).astype(np.uint8)
if not using_encoding:
# labels includes loc, landm, landm_valid.
targets = labels.numpy()[0]
for target in targets:
def main(_):
min_sizes = [[16, 32], [64, 128], [256, 512]]
steps = [8, 16, 32]
clip = False
img_dim = 640
priors = prior_box((img_dim, img_dim), min_sizes, steps, clip)
variances = [0.1, 0.2]
match_thresh = 0.45
ignore_thresh = 0.3
batch_size = 1
shuffle = True
using_flip = True
using_distort = True
using_bin = True
buffer_size = 4000
number_cycles = 2
threads = 2
check_dataset = load_tfrecord_dataset(dataset_root=FLAGS.dataset_path,
split=FLAGS.split,
threads=threads,
number_cycles=number_cycles,
batch_size=batch_size,
hvd=[],
img_dim=img_dim,
using_bin=using_bin,
using_flip=using_flip,
using_distort=using_distort,
using_encoding=FLAGS.using_encoding,
priors=priors,
match_thresh=match_thresh,
ignore_thresh=ignore_thresh,
variances=variances,
shuffle=shuffle,
buffer_size=buffer_size)
time.time()
for idx, (inputs, labels, _) in enumerate(check_dataset):
print("{} inputs:".format(idx), inputs.shape, "labels:", labels.shape)
if not FLAGS.visualization:
continue
img = np.clip(inputs.numpy()[0], 0, 255).astype(np.uint8)
if not FLAGS.using_encoding:
# labels includes loc, landm, landm_valid.
targets = labels.numpy()[0]
for target in targets:
draw_bbox_landm(img, target, img_dim, img_dim)
else:
# labels includes loc, landm, landm_valid, conf.
targets = decode_tf(labels[0], priors, variances=variances).numpy()
for prior_index in range(len(targets)):
if targets[prior_index][-1] != 1:
continue
draw_bbox_landm(img, targets[prior_index], img_dim, img_dim)
draw_anchor(img, priors[prior_index], img_dim, img_dim)
cv2.imwrite('{}/{}.png'.format(FLAGS.output_path, str(idx)),
img[:, :, ::-1])
def main(_):
min_sizes = [[16, 32], [64, 128], [256, 512]]
steps = [8, 16, 32]
clip = False
img_dim = 640
priors = prior_box((img_dim, img_dim), min_sizes, steps, clip)
variances = [0.1, 0.2]
match_thresh = 0.45
ignore_thresh = 0.3
num_samples = 100
if FLAGS.using_encoding:
assert FLAGS.batch_size == 1
if FLAGS.using_bin:
tfrecord_name = './data/widerface_train_bin.tfrecord'
else:
tfrecord_name = './data/widerface_train.tfrecord'
train_dataset = load_tfrecord_dataset(tfrecord_name,
FLAGS.batch_size,
img_dim=640,
using_bin=FLAGS.using_bin,
using_flip=True,
using_distort=False,
using_encoding=FLAGS.using_encoding,
priors=priors,
match_thresh=match_thresh,
ignore_thresh=ignore_thresh,
variances=variances,
shuffle=False)
start_time = time.time()
for idx, (inputs, labels) in enumerate(train_dataset.take(num_samples)):
print("{} inputs:".format(idx), inputs.shape, "labels:", labels.shape)
if not FLAGS.visualization:
continue
img = np.clip(inputs.numpy()[0], 0, 255).astype(np.uint8)
if not FLAGS.using_encoding:
# labels includes loc, landm, landm_valid.
targets = labels.numpy()[0]
for target in targets:
draw_bbox_landm(img, target, img_dim, img_dim)
else:
# labels includes loc, landm, landm_valid, conf.
targets = decode_tf(labels[0], priors, variances=variances).numpy()
for prior_index in range(len(targets)):
if targets[prior_index][-1] != 1:
continue
draw_bbox_landm(img, targets[prior_index], img_dim, img_dim)
draw_anchor(img, priors[prior_index], img_dim, img_dim)
cv2.imshow('img', cv2.cvtColor(img, cv2.COLOR_RGB2BGR))
if cv2.waitKey(0) == ord('q'):
exit()
print("data fps: {:.2f}".format(num_samples / (time.time() - start_time)))
def main(_):
set_memory_growth()
cfg = load_yaml(FLAGS.cfg_path)
model = ArcFaceModel(size=cfg['input_size'],
backbone_type=cfg['backbone_type'],
num_classes=cfg['num_classes'],
head_type=cfg['head_type'],
embd_shape=cfg['embd_shape'],
w_decay=cfg['w_decay'],
training=True)
model.summary()
learning_rate = tf.constant(cfg['base_lr'])
optimizer = tf.keras.optimizers.SGD(learning_rate=learning_rate,
momentum=0.9,
nesterov=True)
loss_fn = SoftmaxLoss()
ckpt_path = tf.train.latest_checkpoint('./checkpoints/' + cfg['sub_name'])
if ckpt_path is not None:
print("[*] load ckpt from {}".format(ckpt_path))
model.load_weights(ckpt_path)
else:
print("[*] training from scratch.")
model.compile(optimizer=optimizer, loss=loss_fn)
data_path = 'data'
lfw, lfw_issame = get_val_pair(data_path, 'lfw_align_112/lfw')
lfw = np.transpose(lfw, [0, 2, 3, 1]) * 0.5 + 0.5
image_1 = lfw[0::2]
image_2 = lfw[1::2]
augment = ImgAugTransform()
if FLAGS.mode == 'eager_tf':
top_left_all = [0.008807]
for epochs in range(cfg['epochs']):
logging.info("Shuffle ms1m dataset.")
dataset_len = cfg['num_samples']
steps_per_epoch = dataset_len // cfg['batch_size']
train_dataset = dataset.load_tfrecord_dataset(
cfg['train_dataset'],
cfg['batch_size'],
cfg['binary_img'],
is_ccrop=cfg['is_ccrop'])
for batch, (x, y) in enumerate(train_dataset):
x0_new = np.array(x[0], dtype=np.uint8)
x1_new = np.array(x[1], dtype=np.float32)
for i in np.arange(len(x0_new)):
x0_new[i] = augment(x0_new[i])
temp = np.array(x0_new, dtype=np.float32) / 255.0
loss = model.train_on_batch(*((temp, x1_new), x1_new))
if batch % 50 == 0:
verb_str = "Epoch {}/{}: {}/{}, loss={:.6f}, lr={:.6f}"
print(
verb_str.format(
epochs, cfg['epochs'], batch, steps_per_epoch,
loss, cfg['base_lr'] / (1.0 + cfg['w_decay'] *
(epochs * 45489 + batch))))
if batch % cfg['save_steps'] == 0:
resnet_model = tf.keras.Model(
inputs=model.get_layer('resnet50').input,
outputs=model.get_layer('resnet50').output)
output_model = tf.keras.Model(
inputs=model.get_layer('OutputLayer').input,
outputs=model.get_layer('OutputLayer').output)
dist_all = []
top_left_batch = []
for idx in range(0, len(lfw_issame),
cfg['batch_size']):
tem = resnet_model.predict(
image_1[idx:idx + cfg['batch_size']])
embeds_1 = output_model.predict(tem)
norm_embeds_1 = preprocessing.normalize(embeds_1,
norm='l2',
axis=1)
tem = resnet_model.predict(
image_2[idx:idx + cfg['batch_size']])
embeds_2 = output_model.predict(tem)
norm_embeds_2 = preprocessing.normalize(embeds_2,
norm='l2',
axis=1)
diff = np.subtract(norm_embeds_1, norm_embeds_2)
dist = np.sqrt(np.sum(np.square(diff), 1)) / 2
dist_all.extend(dist)
thresholds = np.arange(0, 1, 0.01)
for thr in thresholds:
tpr, fpr, _ = calculate_accuracy(
thr, np.array(dist_all), lfw_issame)
top_left = np.sqrt((1 - tpr)**2 + fpr**2)
top_left_batch.append(top_left)
print(
"The current top left: {:.6f} Threshold: {:.2f}"
.format(np.min(top_left_batch),
0.01 * np.argmin(top_left_batch)))
if not len(top_left_all):
print(
"The best top left: {:.6f} Threshold: {:.2f}"
.format(np.min(top_left_batch),
0.01 * np.argmin(top_left_batch)))
else:
print("The best top left: {:.6f}".format(
top_left_all[-1]))
if not len(top_left_all):
top_left_all.append(np.min(top_left_batch))
print('[*] save ckpt file!')
model.save_weights(
'checkpoints/{}/e_{}_b_{}.ckpt'.format(
cfg['sub_name'], epochs,
batch % steps_per_epoch))
elif top_left_all[-1] > np.min(top_left_batch):
top_left_all.append(np.min(top_left_batch))
print('[*] save ckpt file!')
model.save_weights(
'checkpoints/{}/e_{}_b_{}.ckpt'.format(
cfg['sub_name'], epochs,
batch % steps_per_epoch))
model.save_weights('checkpoints/train_{}/{}.ckpt'.format(
cfg['sub_name'], cfg['sub_name']))
