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']))
def main(_argv): # init 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_path = "./configs/retinaface_mbv2.yaml" cfg = load_yaml(cfg_path) # define network model = RetinaFaceModel(cfg, training=False, iou_th=FLAGS.iou_th, score_th=FLAGS.score_th) # load checkpoint checkpoint_dir = './checkpoints/' + cfg['sub_name'] checkpoint = tf.train.Checkpoint(model=model) if tf.train.latest_checkpoint(checkpoint_dir): checkpoint.restore(tf.train.latest_checkpoint(checkpoint_dir)) print("[*] load ckpt from {}.".format( tf.train.latest_checkpoint(checkpoint_dir))) else: print("[*] Cannot find ckpt from {}.".format(checkpoint_dir)) exit() if not FLAGS.webcam: if not os.path.exists(FLAGS.img_path): print(f"cannot find image path from {FLAGS.img_path}") exit() print("[*] Processing on single image {}".format(FLAGS.img_path)) img_raw = cv2.imread(FLAGS.img_path) img_height_raw, img_width_raw, _ = img_raw.shape img = np.float32(img_raw.copy()) if FLAGS.down_scale_factor < 1.0: img = cv2.resize(img, (0, 0), fx=FLAGS.down_scale_factor, fy=FLAGS.down_scale_factor, interpolation=cv2.INTER_LINEAR) img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) # pad input image to avoid unmatched shape problem img, pad_params = pad_input_image(img, max_steps=max(cfg['steps'])) # run model outputs = model(img[np.newaxis, ...]).numpy() # recover padding effect outputs = recover_pad_output(outputs, pad_params) # draw and save results save_img_path = os.path.join('out_' + os.path.basename(FLAGS.img_path)) for prior_index in range(len(outputs)): draw_bbox_landm(img_raw, outputs[prior_index], img_height_raw, img_width_raw) cv2.imwrite(save_img_path, img_raw) print(f"[*] save result at {save_img_path}") else: cam = cv2.VideoCapture(0) start_time = time.time() while True: _, frame = cam.read() if frame is None: print("no cam input") frame_height, frame_width, _ = frame.shape img = np.float32(frame.copy()) if FLAGS.down_scale_factor < 1.0: img = cv2.resize(img, (0, 0), fx=FLAGS.down_scale_factor, fy=FLAGS.down_scale_factor, interpolation=cv2.INTER_LINEAR) img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) # pad input image to avoid unmatched shape problem img, pad_params = pad_input_image(img, max_steps=max(cfg['steps'])) # run model outputs = model(img[np.newaxis, ...]).numpy() # recover padding effect outputs = recover_pad_output(outputs, pad_params) # draw results for prior_index in range(len(outputs)): draw_bbox_landm(frame, outputs[prior_index], frame_height, frame_width) # calculate fps fps_str = "FPS: %.2f" % (1 / (time.time() - start_time)) start_time = time.time() cv2.putText(frame, fps_str, (25, 25), cv2.FONT_HERSHEY_DUPLEX, 0.75, (0, 255, 0), 2) # show frame cv2.imshow('frame', frame) if cv2.waitKey(1) == ord('q'): exit()
def main(_argv): pipe = rs.pipeline() # Build config object and request pose data cfg = rs.config() cfg.enable_stream(rs.stream.color) # Start streaming with requested config pipe.start(cfg) 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'], training=False) 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("[*] Cannot find ckpt from {}.".format(ckpt_path)) exit() if FLAGS.update: print('Face bank updating...') targets, names = prepare_facebank(cfg, model) print('Face bank updated') else: targets, names = load_facebank(cfg) print('Face bank loaded') if FLAGS.save: video_writer = cv2.VideoWriter('./recording.avi', cv2.VideoWriter_fourcc(*'XVID'), 10, (640, 480)) # frame rate 6 due to my laptop is quite slow... while True: frame = pipe.wait_for_frames() img = frame img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) bboxes, landmarks, faces = align_multi( cfg, img, min_confidence=FLAGS.min_confidence, limits=3) bboxes = bboxes.astype(int) embs = [] for face in faces: if len(face.shape) == 3: face = np.expand_dims(face, 0) face = face.astype(np.float32) / 255. embs.append(l2_norm(model(face)).numpy()) list_min_idx = [] list_score = [] for emb in embs: dist = [euclidean(emb, target) for target in targets] min_idx = np.argmin(dist) list_min_idx.append(min_idx) list_score.append(dist[int(min_idx)]) list_min_idx = np.array(list_min_idx) list_score = np.array(list_score) list_min_idx[list_score > FLAGS.threshold] = -1 for idx, box in enumerate(bboxes): frame = utils.draw_box_name(box, landmarks[idx], names[list_min_idx[idx] + 1], frame) frame = cv2.resize(frame, (640, 480)) cv2.imshow('face Capture', frame) key = cv2.waitKey(1) & 0xFF if FLAGS.save: video_writer.write(frame) if key == ord('q'): break if FLAGS.save: video_writer.release() pipe.stop()
def main(_): # init 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) # define network model = RRDB_Model(cfg['input_size'], cfg['ch_size'], cfg['network_G']) model.summary(line_length=80) # load dataset train_dataset = load_dataset(cfg, 'train_dataset', shuffle=True) # define optimizer learning_rate = MultiStepLR(cfg['lr'], cfg['lr_steps'], cfg['lr_rate']) optimizer = tf.keras.optimizers.Adam(learning_rate=learning_rate, beta_1=cfg['adam_beta1_G'], beta_2=cfg['adam_beta2_G']) # define losses function pixel_loss_fn = PixelLoss(criterion=cfg['pixel_criterion']) # load checkpoint checkpoint_dir = './checkpoints/' + cfg['sub_name'] checkpoint = tf.train.Checkpoint(step=tf.Variable(0, name='step'), optimizer=optimizer, model=model) manager = tf.train.CheckpointManager(checkpoint=checkpoint, directory=checkpoint_dir, max_to_keep=3) if manager.latest_checkpoint: checkpoint.restore(manager.latest_checkpoint) print('[*] load ckpt from {} at step {}.'.format( manager.latest_checkpoint, checkpoint.step.numpy())) else: print("[*] training from scratch.") # define training step function @tf.function def train_step(lr, hr): with tf.GradientTape() as tape: sr = model(lr, training=True) losses = {} losses['reg'] = tf.reduce_sum(model.losses) losses['pixel'] = cfg['w_pixel'] * pixel_loss_fn(hr, sr) total_loss = tf.add_n([l for l in losses.values()]) grads = tape.gradient(total_loss, model.trainable_variables) optimizer.apply_gradients(zip(grads, model.trainable_variables)) return total_loss, losses # training loop summary_writer = tf.summary.create_file_writer('./logs/' + cfg['sub_name']) prog_bar = ProgressBar(cfg['niter'], checkpoint.step.numpy()) remain_steps = max(cfg['niter'] - checkpoint.step.numpy(), 0) for lr, hr in train_dataset.take(remain_steps): checkpoint.step.assign_add(1) steps = checkpoint.step.numpy() total_loss, losses = train_step(lr, hr) prog_bar.update("loss={:.4f}, lr={:.1e}".format( total_loss.numpy(), optimizer.lr(steps).numpy())) if steps % 10 == 0: with summary_writer.as_default(): tf.summary.scalar('loss/total_loss', total_loss, step=steps) for k, l in losses.items(): tf.summary.scalar('loss/{}'.format(k), l, step=steps) tf.summary.scalar('learning_rate', optimizer.lr(steps), step=steps) if steps % cfg['save_steps'] == 0: manager.save() print("\n[*] save ckpt file at {}".format( manager.latest_checkpoint)) print("\n[*] training done!")
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) 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'], 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)) epochs, steps = get_ckpt_inf(ckpt_path) model.load_weights(ckpt_path) else: print('[*] training from scratch.') epochs = 1 steps = 0 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']) while epochs < cfg['epochs'] + 1: for inputs, labels in train_dataset: with tf.GradientTape() as tape: logist = model(inputs, training=True) reg_loss = tf.reduce_sum(model.losses) * cfg['w_decay'] 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 and steps > 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 % 1000 == 0 and steps > 0: print('[*] save ckpt file!') ckpt_name = 'checkpoints/{}/e_{}_s_{}.ckpt' model.save_weights( ckpt_name.format(cfg['sub_name'], epochs, steps)) steps += 1 epochs += 1 else: model.compile(optimizer=optimizer, loss=loss_fn, run_eagerly=(FLAGS.mode == 'eager_fit')) mc_callback = ModelCheckpoint( 'checkpoints/' + cfg['sub_name'] + '/e_{epoch}_s_{batch}.ckpt', save_freq=1000 * cfg['batch_size'] + 1, 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)
def main(): # with open('/home/anhdq23/Desktop/nguyen/VT_simulation/weights/arcface_ret50.json', 'r') as f: # model_json = json.load(f) # model = model_from_json(model_json) # model.load_weights('/home/anhdq23/Desktop/nguyen/VT_simulation/weights/arcface_ret50.h5') cfg = load_yaml('./configs/arc_res50.yaml') 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=False) 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.") 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) temp1 = np.ones((1,17,28,256)) temp2 = np.zeros((1,11,28,256)) masked = np.concatenate([temp1, temp2], axis =1) path_to_data = '/home/anhdq23/Desktop/nguyen/data/AR/test2' anchor_names = get_probe_pr2(path_to_data) # From 1 to 100 name_dicts = get_probe_pr2(path_to_data) # Dictionary: {anchor_name:[name_image, ...]} dist_all = [] labels_ARface = [] # Calculate label for protocol2 for subject in np.arange(100): tmp = np.zeros((600,)) tmp[subject*6: subject*6+6] += 1 labels_ARface.extend(list(tmp)) labels_ARface = np.array(labels_ARface) # Extract featre with padding for anchor_name in anchor_names: start = time.time() for key in list(name_dicts.keys()): print(key) for name in name_dicts[key]: img1 = Image.open(os.path.join(path_to_data, anchor_name)) img1 = expand2square(img1, (255, 255, 255)) img1 = img1.resize((112, 112)) img1 = np.array(img1)/255.0 img2 = Image.open(os.path.join(path_to_data, name)).resize((112, 112)) img2 = expand2square(img2, (255, 255, 255)) img2 = img2.resize((112, 112)) img2 = np.array(img2)/255.0 fc1 = resnet_head.predict(img1.reshape((1,112,112,3))) fc1 = np.multiply(fc1, masked) fc1 = resnet_tail.predict(fc1) fc1 = output_model.predict(fc1) norm_fc1 = preprocessing.normalize(fc1.reshape((1,512)), norm='l2', axis=1) fc2 = resnet_head.predict(img2.reshape((1,112,112,3))) fc2 = np.multiply(fc2, masked) fc2 = resnet_tail.predict(fc2) fc2 = output_model.predict(fc2) norm_fc2 = preprocessing.normalize(fc2.reshape((1,512)), norm='l2', axis=1) diff = np.subtract(norm_fc1, norm_fc2) dist = np.sqrt(np.sum(np.square(diff), 1))/2 print(dist, anchor_name, name) dist_all.extend(dist) end = time.time() print(end - start) plt.plot(dist_all) plt.show() thresholds = np.arange(0, 1, 0.01) tpr_all = [] fpr_all = [] for thr in thresholds: tpr, fpr, acc, f1 = calculate_accuracy(thr, np.array(dist_all), labels_ARface) top_left = np.sqrt((1-tpr)**2 + fpr**2) print('thr %.4f' % thr , 'tpr %.4f' % tpr, 'fpr %.4f' % fpr, \ 'top left %.4f' % top_left, 'acc %.4f' % acc, 'f1_score %.4f'%f1) # top_left_batch.append(top_left) tpr_all.append(tpr) fpr_all.append(fpr) for threshold in thresholds: predict_issame = np.less(np.array(dist_all), threshold) conf_matrix = confusion_matrix(labels_ARface, predict_issame) print(conf_matrix) plt.figure() lw = 2 plt.plot(fpr_all, tpr_all, color='darkorange', lw=lw, label='ROC curve') plt.xlim([0.0, 1.]) plt.ylim([0.0, 1.]) plt.xlabel('False Positive Rate') plt.ylabel('True Positive Rate') plt.title('Receiver operating characteristic') plt.legend(loc="lower right") plt.show()
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 = Modelembedding( size=cfg['input_size'], embd_shape=cfg['embd_shape'], backbone_type=cfg['backbone_type'], training= True, # here equal false, just get the model without acrHead, to load the model trained by arcface cfg=cfg) cifar = Cifar(cfg['batch_size']) train_dataset = cifar.build_training_data() val_dataset = cifar.build_validation_data() dataset_len = cfg['num_samples'] steps_per_epoch = dataset_len // cfg['batch_size'] learning_rate = tf.constant(cfg['base_lr']) optimizer = tf.keras.optimizers.Adam(learning_rate=learning_rate) # optimizer = tf.keras.optimizers.SGD(learning_rate=0.01, momentum=0.9) # optimiser = tf.train.MomentumOptimizer(learning_rate,momentum=0.9, ) for x in model.trainable_weights: print("trainable:", x.name) print('\n') model.summary(line_length=80) 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) marginloss = MarginLossLayer2(cfg=cfg) while epochs <= cfg['epochs']: if steps % 5 == 0: start = time.time() inputs, labels = next( train_dataset) #print(inputs[0][1][:]) labels[2][:] with tf.GradientTape() as tape: logist = model((inputs, labels), training=True) reg_loss = tf.reduce_sum(model.losses) pred_loss = marginloss(logist, labels) # logist = tf.cast(logist,tf.double) total_loss = reg_loss + pred_loss grads = tape.gradient(total_loss, model.trainable_variables) optimizer.apply_gradients(zip(grads, model.trainable_variables)) if steps % 5 == 0: end = time.time() verb_str = "Epoch {}/{}: {}/{}, loss={:.2f}, lr={:.4f}, time per step={:.2f}s, remaining time 4 this epoch={:.2f}min" print( verb_str.format(epochs, cfg['epochs'], steps % steps_per_epoch, steps_per_epoch, total_loss.numpy(), learning_rate.numpy(), end - start, (steps_per_epoch - (steps % steps_per_epoch)) * (end - start) / 60.0)) 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: print("[*] only support eager_tf!") marginloss = MarginLossLayer2(cfg=cfg) model.compile(optimizer=optimizer, loss=marginloss) 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/' + cfg['sub_name'], 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] def batch_generator(train_dataset): train_dataset = iter(train_dataset) while True: inputs, labels = next( train_dataset) #print(inputs[0][1][:]) labels[2][:] yield [inputs, labels] model.fit_generator(batch_generator(train_dataset), epochs=cfg['epochs'], steps_per_epoch=steps_per_epoch, callbacks=callbacks, initial_epoch=epochs - 1) print("[*] training done!")
def test_model_selector_creation(config: dict, problem_type: str): path = config.get('MODEL_SELECTOR_CONFIG_DIR') path = os.path.join(path, f'{problem_type}.yml') model_selector_config = load_yaml(path=path) assert ModelSelector(config=model_selector_config)
if hvd.rank() == 0: manager.save() print("\n[*] training done! save ckpt file at {}".format( manager.latest_checkpoint)) else: manager.save() print("\n[*] training done! save ckpt file at {}".format( manager.latest_checkpoint)) def get_args(): parser = argparse.ArgumentParser( description='RetinaFace train') parser.add_argument('--dataset_root', required=True, help='Dataset path', type=str) parser.add_argument('--output_path', required=True, help='Output path', type=str) parser.add_argument('--cfg_path', required=True, help='Config file path', type=str) args = parser.parse_args() return args if __name__ == '__main__': args = get_args() cfg = load_yaml(args.cfg_path) cfg['dataset_root'] = args.dataset_root cfg['output_path'] = args.output_path train_retinaface(cfg)
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) if FLAGS.v_tf == '2': 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, version_tensorflow=FLAGS.v_tf) 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.") steps_per_epoch = 1 train_dataset = dataset.load_fake_dataset(cfg['input_size']) ckpt_path = tf.train.latest_checkpoint(cfg['checkpoints_dir'] + 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': learning_rate = 0.1 optimizer = tf.keras.optimizers.SGD(learning_rate=learning_rate, decay=1e-4, momentum=0.9, nesterov=True) loss_fn = SoftmaxLoss() # Eager mode is great for debugging # Non eager graph mode is recommended for real training summary_writer = tf.summary.create_file_writer(cfg['logs_dir'] + 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={:.2f}" print( verb_str.format(epochs, cfg['epochs'], steps % steps_per_epoch, steps_per_epoch, total_loss.numpy(), optimizer.lr.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('{}{}/e_{}_b_{}.ckpt'.format( cfg['checkpoints_dir'], cfg['sub_name'], epochs, steps % steps_per_epoch)) steps += 1 epochs = steps // steps_per_epoch + 1 else: learning_rate = 0.1 optimizer = tf.keras.optimizers.SGD(learning_rate=learning_rate, decay=1e-4, momentum=0.9, nesterov=True) loss_fn = SoftmaxLoss() model.compile(optimizer=optimizer, loss=loss_fn) mc_callback = ModelCheckpoint( cfg['checkpoints_dir'] + 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=cfg['logs_dir'] + cfg['sub_name'], update_freq=cfg['batch_size'] * 5, profile_batch=0) tb_callback._total_batches_seen = steps tb_callback._samples_seen = steps * cfg['batch_size'] #lrate = LearningRateScheduler(step_decay) #callbacks = [mc_callback, tb_callback, lrate] callbacks = [mc_callback, tb_callback] model.fit(train_dataset, epochs=cfg['epochs'], steps_per_epoch=steps_per_epoch, callbacks=callbacks, initial_epoch=epochs - 1) print("[*] training done!")
def main(_): # init 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) # define network sna = SearchNetArch(cfg) sna.model.summary(line_length=80) print("param size = {:f}MB".format(count_parameters_in_MB(sna.model))) # load dataset t_split = f"train[0%:{int(cfg['train_portion'] * 100)}%]" v_split = f"train[{int(cfg['train_portion'] * 100)}%:100%]" train_dataset = load_cifar10_dataset( cfg['batch_size'], split=t_split, shuffle=True, drop_remainder=True, using_normalize=cfg['using_normalize'], using_crop=cfg['using_crop'], using_flip=cfg['using_flip'], using_cutout=cfg['using_cutout'], cutout_length=cfg['cutout_length']) val_dataset = load_cifar10_dataset(cfg['batch_size'], split=v_split, shuffle=True, drop_remainder=True, using_normalize=cfg['using_normalize'], using_crop=cfg['using_crop'], using_flip=cfg['using_flip'], using_cutout=cfg['using_cutout'], cutout_length=cfg['cutout_length']) # define optimizer steps_per_epoch = int(cfg['dataset_len'] * cfg['train_portion'] // cfg['batch_size']) learning_rate = CosineAnnealingLR(initial_learning_rate=cfg['init_lr'], t_period=cfg['epoch'] * steps_per_epoch, lr_min=cfg['lr_min']) optimizer = tf.keras.optimizers.SGD(learning_rate=learning_rate, momentum=cfg['momentum']) optimizer_arch = tf.keras.optimizers.Adam( learning_rate=cfg['arch_learning_rate'], beta_1=0.5, beta_2=0.999) # define losses function criterion = CrossEntropyLoss() # load checkpoint checkpoint_dir = './checkpoints/' + cfg['sub_name'] checkpoint = tf.train.Checkpoint(step=tf.Variable(0, name='step'), optimizer=optimizer, optimizer_arch=optimizer_arch, model=sna.model, alphas_normal=sna.alphas_normal, alphas_reduce=sna.alphas_reduce, betas_normal=sna.betas_normal, betas_reduce=sna.betas_reduce) manager = tf.train.CheckpointManager(checkpoint=checkpoint, directory=checkpoint_dir, max_to_keep=3) if manager.latest_checkpoint: checkpoint.restore(manager.latest_checkpoint) print('[*] load ckpt from {} at step {}.'.format( manager.latest_checkpoint, checkpoint.step.numpy())) else: print("[*] training from scratch.") print(f"[*] searching model after {cfg['start_search_epoch']} epochs.") # define training step function for model @tf.function def train_step(inputs, labels): with tf.GradientTape() as tape: logits = sna.model((inputs, *sna.arch_parameters), training=True) losses = {} losses['reg'] = tf.reduce_sum(sna.model.losses) losses['ce'] = criterion(labels, logits) total_loss = tf.add_n([l for l in losses.values()]) grads = tape.gradient(total_loss, sna.model.trainable_variables) grads = [(tf.clip_by_norm(grad, cfg['grad_clip'])) for grad in grads] optimizer.apply_gradients(zip(grads, sna.model.trainable_variables)) return logits, total_loss, losses # define training step function for arch_parameters @tf.function def train_step_arch(inputs, labels): with tf.GradientTape() as tape: logits = sna.model((inputs, *sna.arch_parameters), training=True) losses = {} losses['reg'] = cfg['arch_weight_decay'] * tf.add_n( [tf.reduce_sum(p**2) for p in sna.arch_parameters]) losses['ce'] = criterion(labels, logits) total_loss = tf.add_n([l for l in losses.values()]) grads = tape.gradient(total_loss, sna.arch_parameters) optimizer_arch.apply_gradients(zip(grads, sna.arch_parameters)) return losses # training loop summary_writer = tf.summary.create_file_writer('./logs/' + cfg['sub_name']) total_steps = steps_per_epoch * cfg['epoch'] remain_steps = max(total_steps - checkpoint.step.numpy(), 0) prog_bar = ProgressBar(steps_per_epoch, checkpoint.step.numpy() % steps_per_epoch) train_acc = AvgrageMeter() for inputs, labels in train_dataset.take(remain_steps): checkpoint.step.assign_add(1) steps = checkpoint.step.numpy() epochs = ((steps - 1) // steps_per_epoch) + 1 if epochs > cfg['start_search_epoch']: inputs_val, labels_val = next(iter(val_dataset)) arch_losses = train_step_arch(inputs_val, labels_val) logits, total_loss, losses = train_step(inputs, labels) train_acc.update( accuracy(logits.numpy(), labels.numpy())[0], cfg['batch_size']) prog_bar.update( "epoch={:d}/{:d}, loss={:.4f}, acc={:.2f}, lr={:.2e}".format( epochs, cfg['epoch'], total_loss.numpy(), train_acc.avg, optimizer.lr(steps).numpy())) if steps % 10 == 0: with summary_writer.as_default(): tf.summary.scalar('acc/train', train_acc.avg, step=steps) tf.summary.scalar('loss/total_loss', total_loss, step=steps) for k, l in losses.items(): tf.summary.scalar('loss/{}'.format(k), l, step=steps) tf.summary.scalar('learning_rate', optimizer.lr(steps), step=steps) if epochs > cfg['start_search_epoch']: for k, l in arch_losses.items(): tf.summary.scalar('arch_losses/{}'.format(k), l, step=steps) tf.summary.scalar('arch_learning_rate', cfg['arch_learning_rate'], step=steps) if steps % cfg['save_steps'] == 0: manager.save() print("\n[*] save ckpt file at {}".format( manager.latest_checkpoint)) if steps % steps_per_epoch == 0: train_acc.reset() if epochs > cfg['start_search_epoch']: genotype = sna.get_genotype() print(f"\nsearch arch: {genotype}") f = open( os.path.join('./logs', cfg['sub_name'], 'search_arch_genotype.py'), 'a') f.write(f"\n{cfg['sub_name']}_{epochs} = {genotype}\n") f.close() manager.save() print("\n[*] training done! save ckpt file at {}".format( manager.latest_checkpoint))
from modules.trainer import CustomTrainer from modules.utils import load_yaml, save_yaml, get_logger, make_directory iou_thres = 0.75 device = 'cuda' if torch.cuda.is_available() else 'cpu' print("The following GPU devices are available: %s" % device) # DEBUG DEBUG = False # CONFIG PROJECT_DIR = os.path.dirname(os.path.abspath(__file__)) ROOT_PROJECT_DIR = os.path.dirname(PROJECT_DIR) DATA_DIR = os.path.join(PROJECT_DIR, 'data') TRAIN_CONFIG_PATH = os.path.join(PROJECT_DIR, 'config/train_config.yaml') config = load_yaml(TRAIN_CONFIG_PATH) # SEED RANDOM_SEED = config['SEED']['random_seed'] # DATALOADER NUM_WORKERS = config['DATALOADER']['num_workers'] CHECKPOINT_PATH = '' PIN_MEMORY = config['DATALOADER']['pin_memory'] # TRAIN EPOCHS = config['TRAIN']['num_epochs'] TRAIN_BATCH_SIZE = config['TRAIN']['batch_size'] MODEL = config['TRAIN']['model'] LEARNING_RATE = config['TRAIN']['learning_rate'] EARLY_STOPPING_PATIENCE = config['TRAIN']['early_stopping_patience']
def main(_argv): 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'], training=False) 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("[*] Cannot find ckpt from {}.".format(ckpt_path)) exit() if FLAGS.img_path: print("[*] Encode {} to ./output_embeds.npy".format(FLAGS.img_path)) img = cv2.imread(FLAGS.img_path) img = cv2.resize(img, (cfg['input_size'], cfg['input_size'])) img = img.astype(np.float32) / 255. if len(img.shape) == 3: img = np.expand_dims(img, 0) embeds = l2_norm(model(img)) np.save('./output_embeds.npy', embeds) else: print("[*] Loading LFW, AgeDB30 and CFP-FP...") lfw, agedb_30, cfp_fp, lfw_issame, agedb_30_issame, cfp_fp_issame = \ get_val_data(cfg['test_dataset']) print("[*] Perform Evaluation on LFW...") acc_lfw, best_th = perform_val(cfg['embd_shape'], cfg['batch_size'], model, lfw, lfw_issame, is_ccrop=cfg['is_ccrop']) print(" acc {:.4f}, th: {:.2f}".format(acc_lfw, best_th)) print("[*] Perform Evaluation on AgeDB30...") acc_agedb30, best_th = perform_val(cfg['embd_shape'], cfg['batch_size'], model, agedb_30, agedb_30_issame, is_ccrop=cfg['is_ccrop']) print(" acc {:.4f}, th: {:.2f}".format(acc_agedb30, best_th)) print("[*] Perform Evaluation on CFP-FP...") acc_cfp_fp, best_th = perform_val(cfg['embd_shape'], cfg['batch_size'], model, cfp_fp, cfp_fp_issame, is_ccrop=cfg['is_ccrop']) print(" acc {:.4f}, th: {:.2f}".format(acc_cfp_fp, best_th))
def main(_argv): # FUNCTIONS FOR CROPPING ##################################################################################################### def bounding_box(img, ann, img_height, img_width): x1, y1, x2, y2 = int(ann[0] * img_width), int(ann[1] * img_height), \ int(ann[2] * img_width), int(ann[3] * img_height) return x1, y1, x2, y2 def calc_points(x, y, side): return int(x - side / 2), int(x + side / 2), int(y - side / 2), int(y + side / 2) def adjust_points(x_center, y_center, original_longest, scaling_factor, min_scaling_factor): factors = np.arange(scaling_factor, min_scaling_factor - 0.04, -0.05) for factor in factors: # calculate nex points x1, x2, y1, y2 = calc_points(x_center, y_center, int(original_longest * factor)) for i in range(FLAGS.max_iter): if x1 < 0: x2 -= x1 x1 = 0 if y1 < 0: y2 -= y1 y1 = 0 if x2 > img_raw.shape[1]: x1 -= x2 x2 = img_raw.shape[1] if y2 > img_raw.shape[0]: y1 -= y2 y2 = img_raw.shape[0] if x1 >= 0 and y1 >= 0 and x2 <= img_raw.shape[ 1] and y2 <= img_raw.shape[0]: return x1, x2, y1, y2, True print("Not cropping", img_path, "due to a problem with a cropping square box") return x1, x2, y1, y2, False def get_dim(lst): return [(lst[3] - lst[1]) * (lst[2] - lst[0])] def get_max(outputs, lst): area = [i[0] for i in lst] prob = [i[1] for i in lst] max_area_index = set([i for i, j in enumerate(area) if j == max(area)]) max_prob_index = set([i for i, j in enumerate(prob) if j == max(prob)]) indecies = list(max_area_index.intersection(max_prob_index)) if len(indecies) >= 1: return [outputs[indecies[0]]] elif len(indecies ) == 0: # if there is a mismatch, return the largest element if len(list(max_area_index)) >= 1: return [outputs[list(max_area_index)[0]]] else: # precautionary because there should always be at least one face print("Not cropping", img_path, "due to a problem with returning the largest element") return [] ##################################################################################################### # MODEL ##################################################################################################### # initialisation 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) # define network model = RetinaFaceModel(cfg, training=False, iou_th=FLAGS.iou_th, score_th=FLAGS.score_th) # load checkpoint checkpoint_dir = './checkpoints/' + cfg['sub_name'] checkpoint = tf.train.Checkpoint(model=model) if tf.train.latest_checkpoint(checkpoint_dir): checkpoint.restore(tf.train.latest_checkpoint(checkpoint_dir)) print("[*] load ckpt from {}.".format( tf.train.latest_checkpoint(checkpoint_dir))) else: print("[*] Cannot find ckpt from {}.".format(checkpoint_dir)) exit() ##################################################################################################### # CROPPING ##################################################################################################### # check if the path exits if not os.path.exists(FLAGS.path): print(f"cannot find the specified path from {FLAGS.path}") exit() # make a corresponding directory try: os.mkdir(FLAGS.path.replace("images", "cropped_images")) except FileExistsError: print(FLAGS.path.replace("images", "cropped_images"), "already exists") # eget subdirectories within the specified folder subdirectories = [FLAGS.path+'/'+i for i in os.listdir(FLAGS.path) \ if os.path.isdir(FLAGS.path+'/'+i)] # loop through each folder for subdir in sorted(subdirectories): # create corresponding folders for cropped data and get all images in a given folder if 'original' in subdir: x = 3 else: x = 7 try: os.mkdir(subdir.replace("images", "cropped_images")) images_lst = glob.glob(subdir + "/*.png") cropped_images_lst = [] print(subdir[len(subdir) - x:len(subdir)]) except FileExistsError: # count number of existing images in this subdirectory, if same as original, skip images_lst = glob.glob(subdir + "/*.png") cropped_images_lst = glob.glob( subdir.replace("images", "cropped_images") + "/*.png") cropped_images_lst = [ e[len(e) - 8:len(e)] for e in cropped_images_lst ] if len(images_lst) == len(cropped_images_lst): print(subdir[len(subdir) - x:len(subdir)], "has already been generated") continue else: print(subdir[len(subdir) - x:len(subdir)]) # loop through each image in a given folder for img_path in sorted(images_lst): if img_path[len(img_path) - 8:len(img_path)] in cropped_images_lst: continue img_raw = cv2.imread(img_path) img_height_raw, img_width_raw, _ = img_raw.shape img = np.float32(img_raw.copy()) img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) # pad input image (unmatched shape problem), run model, recover padding effect img, pad_params = pad_input_image(img, max_steps=max(cfg['steps'])) outputs = model(img[np.newaxis, ...]).numpy() outputs = recover_pad_output(outputs, pad_params) # get rid of elements which are faces with less that threshold probability outputs = [i for i in outputs if i[15] >= FLAGS.threshold_prob] # flag any images which have no recognised faces in them if len(outputs) == 0: print("no faces detected for", img_path) # if more than one face detected, select the largest and most definite elif len(outputs) > 1: f = [list(bounding_box(img_raw, i[0:4], img_height_raw, img_width_raw)) + [i[15]] \ for i in outputs] f = [get_dim(i[0:4]) + [i[4]] for i in f] outputs = get_max(outputs, f) # keeping as a loop in case we decide to use multiple faces per frame in the future # get cropping coordinates and save results for prior_index in range(len(outputs)): # get the bounding box coordinates bb_x1, bb_y1, bb_x2, bb_y2 = bounding_box( img_raw, outputs[prior_index], img_height_raw, img_width_raw) # scale up the magnitude of the longest side original_longest = int(max(bb_x2 - bb_x1, bb_y2 - bb_y1)) longest = int(original_longest * FLAGS.scaling_factor) x_center = int((bb_x1 + bb_x2) / 2) y_center = int((bb_y1 + bb_y2) / 2) x1, x2, y1, y2, save_image = adjust_points( x_center, y_center, original_longest, FLAGS.scaling_factor, FLAGS.min_scaling_factor) if save_image: try: save_img_path = os.path.join(subdir.replace("images", "cropped_images") \ + "/" + img_path.replace(subdir + '/', '')) cv2.imwrite(save_img_path, img_raw[y1:y2, x1:x2]) except: print(img_path, "is not cropped for unknown reasons")
def convert_to_tflite(saved_model_dir, output_path, ckpt_path, config): if not Path(saved_model_dir).joinpath("saved_model.pb").exists() and ckpt_path is not None: export_to_saved_model(ckpt_path, saved_model_dir, config, image_size=320) converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir) converter.allow_custom_ops = True tflite_model = converter.convert() with open(output_path, "wb") as fh: fh.write(tflite_model) return tflite_model if __name__ == "__main__": config = load_yaml("configs/retinaface_mbv2.yaml") tflite_model = convert_to_tflite( "saved_models/retinaface_mobile-v2_end2end_fixed-shape", "retinaface_mobile-v2.tflite", "checkpoints/retinaface_mbv2/ckpt-81", config, ) import cv2 import numpy as np # interpreter = tf.lite.Interpreter(model_path="retinaface_mobile-v2.tflite") interpreter = tf.lite.Interpreter(model_content=tflite_model) interpreter.allocate_tensors() input_details = interpreter.get_input_details()
def main(_): # init 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) # define network if cfg['network_G']['name']=='RRDB': # ESRGAN 4x model = RRDB_Model(None, cfg['ch_size'], cfg['network_G']) elif cfg['network_G']['name']=='RRDB_CIPLAB': model = RRDB_Model_16x(None, cfg['ch_size'], cfg['network_G']) elif cfg['network_G']['name']=='RFB_ESRGAN': model = RFB_Model_16x(None, cfg['ch_size'], cfg['network_G']) model.summary(line_length=80) # load dataset train_dataset = load_dataset(cfg, 'train_dataset', shuffle=True) set5_dataset = load_val_dataset(cfg, 'set5') set14_dataset = load_val_dataset(cfg, 'set14') if 'DIV8K' in cfg['test_dataset']: DIV8K_val = load_val_dataset(cfg, 'DIV8K', crop_centor=cfg['test_dataset']['DIV8K_crop_centor']) # define optimizer learning_rate = MultiStepLR(cfg['lr'], cfg['lr_steps'], cfg['lr_rate']) optimizer = tf.keras.optimizers.Adam(learning_rate=learning_rate, beta_1=cfg['adam_beta1_G'], beta_2=cfg['adam_beta2_G']) # define losses function if cfg['cycle_mse']: pixel_loss_fn = PixelLossDown(criterion=cfg['pixel_criterion'], scale=cfg['scale']) else: pixel_loss_fn = PixelLoss(criterion=cfg['pixel_criterion']) # load checkpoint checkpoint_dir = cfg['log_dir'] + '/checkpoints' checkpoint = tf.train.Checkpoint(step=tf.Variable(0, name='step'), optimizer=optimizer, model=model) manager = tf.train.CheckpointManager(checkpoint=checkpoint, directory=checkpoint_dir, max_to_keep=3) if manager.latest_checkpoint: checkpoint.restore(manager.latest_checkpoint) print('[*] load ckpt from {} at step {}.'.format( manager.latest_checkpoint, checkpoint.step.numpy())) else: print("[*] training from scratch.") # define training step function @tf.function def train_step(lr, hr): with tf.GradientTape() as tape: sr = model(lr, training=True) losses = {} losses['reg'] = tf.reduce_sum(model.losses) losses['pixel'] = cfg['w_pixel'] * pixel_loss_fn(hr, sr) total_loss = tf.add_n([l for l in losses.values()]) grads = tape.gradient(total_loss, model.trainable_variables) optimizer.apply_gradients(zip(grads, model.trainable_variables)) return total_loss, losses # training loop summary_writer = tf.summary.create_file_writer(cfg['log_dir']+'/logs') prog_bar = ProgressBar(cfg['niter'], checkpoint.step.numpy()) remain_steps = max(cfg['niter'] - checkpoint.step.numpy(), 0) for _ in range(remain_steps): lr, hr = train_dataset() checkpoint.step.assign_add(1) steps = checkpoint.step.numpy() total_loss, losses = train_step(lr, hr) prog_bar.update("loss={:.4f}, lr={:.1e}".format( total_loss.numpy(), optimizer.lr(steps).numpy())) if steps % 10 == 0: with summary_writer.as_default(): tf.summary.scalar( 'loss/total_loss', total_loss, step=steps) for k, l in losses.items(): tf.summary.scalar('loss/{}'.format(k), l, step=steps) tf.summary.scalar( 'learning_rate', optimizer.lr(steps), step=steps) if steps % cfg['save_steps'] == 0: manager.save() print("\n[*] save ckpt file at {}".format( manager.latest_checkpoint)) # log results on test data set5_logs = evaluate_dataset(set5_dataset, model, cfg) set14_logs = evaluate_dataset(set14_dataset, model, cfg) if 'DIV8K' in cfg['test_dataset']: DIV8K_logs = evaluate_dataset(DIV8K_val, model, cfg) with summary_writer.as_default(): if cfg['logging']['psnr']: tf.summary.scalar('set5/psnr', set5_logs['psnr'], step=steps) tf.summary.scalar('set14/psnr', set14_logs['psnr'], step=steps) if 'DIV8K' in cfg['test_dataset']: tf.summary.scalar('DIV8K/psnr', DIV8K_logs['psnr'], step=steps) if cfg['logging']['ssim']: tf.summary.scalar('set5/ssim', set5_logs['ssim'], step=steps) tf.summary.scalar('set14/ssim', set14_logs['ssim'], step=steps) if 'DIV8K' in cfg['test_dataset']: tf.summary.scalar('DIV8K/psnr', DIV8K_logs['psnr'], step=steps) if cfg['logging']['lpips']: tf.summary.scalar('set5/lpips', set5_logs['lpips'], step=steps) tf.summary.scalar('set14/lpips', set14_logs['lpips'], step=steps) if 'DIV8K' in cfg['test_dataset']: tf.summary.scalar('DIV8K/lpips', DIV8K_logs['lpips'], step=steps) if cfg['logging']['plot_samples']: tf.summary.image("set5/samples", [set5_logs['samples']], step=steps) tf.summary.image("set14/samples", [set14_logs['samples']], step=steps) if 'DIV8K' in cfg['test_dataset']: tf.summary.image("DIV8K/samples", [DIV8K_logs['samples']], step=steps) print("\n[*] training done!")
import time import sys from modules.models import RetinaFaceModel from modules.utils import (set_memory_growth, load_yaml, draw_bbox_landm, pad_input_image, recover_pad_output) set_memory_growth() # tf.debugging.set_log_device_placement(True) cfg_path = './configs/retinaface_mbv2.yaml' gpu = '0' iou_th = 0.4 score_th = 0.5 cfg = load_yaml(cfg_path) model = RetinaFaceModel(cfg, training=False, iou_th=iou_th, score_th=score_th) checkpoint_dir = './checkpoints/' + cfg['sub_name'] checkpoint = tf.train.Checkpoint(model=model) if tf.train.latest_checkpoint(checkpoint_dir): checkpoint.restore(tf.train.latest_checkpoint(checkpoint_dir)) print("[*] load ckpt from {}.".format( tf.train.latest_checkpoint(checkpoint_dir))) else: print("[*] Cannot find ckpt from {}.".format(checkpoint_dir)) exit() # 부모모듈 경로 가져오기 sys.path.append(os.path.dirname(os.path.abspath(os.path.dirname(__file__))))
def model_selector_regression(config: dict): path = config.get('MODEL_SELECTOR_CONFIG_DIR') path = os.path.join(path, 'regression.yml') model_selector_config = load_yaml(path=path) return ModelSelector(config=model_selector_config)
def __len__(self): return len(self.datas_list) def __getitem__(self, index): data = np.load(self.datas_list[index], allow_pickle=True).item() if self.is_aug: data = self.data_aug(data) data['Image'] = (data['Image'] / 255.).astype(np.float32) data['Posmap'] = (data['Posmap'] / 255.).astype(np.float32) return data if __name__ == '__main__': cfg = load_yaml('./configs/prnet.yaml') train_dataset = load_dataset(cfg, shuffle=False) remain_steps = 100000 print(len(train_dataset.dataset)) model = PRN(cfg, is_dlib=True) for sample in take(remain_steps, train_dataset): for idx in range(cfg['batch_size']): img, pos = sample['Image'][idx], sample['Posmap'][idx] vertices = model.get_vertices(pos) cv2.imshow('img', img) cv2.imshow('pos', pos) cv2.imshow('Dense alignment', plot_vertices(img, vertices * 255.)) if cv2.waitKey(0) == 113: exit()
def main(_argv): # init 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) # define network model = RetinaFaceModel(cfg, training=False, iou_th=FLAGS.iou_th, score_th=FLAGS.score_th) # load checkpoint checkpoint_dir = './checkpoints/' + cfg['sub_name'] checkpoint = tf.train.Checkpoint(model=model) if tf.train.latest_checkpoint(checkpoint_dir): checkpoint.restore(tf.train.latest_checkpoint(checkpoint_dir)) print("[*] load ckpt from {}.".format( tf.train.latest_checkpoint(checkpoint_dir))) else: print("[*] Cannot find ckpt from {}.".format(checkpoint_dir)) exit() if not FLAGS.webcam: if not os.path.exists(FLAGS.img_path): print(f"cannot find image path from {FLAGS.img_path}") exit() print("[*] Processing on single image {}".format(FLAGS.img_path)) img_raw = cv2.imread(FLAGS.img_path) img_height_raw, img_width_raw, _ = img_raw.shape img = np.float32(img_raw.copy()) if FLAGS.down_scale_factor < 1.0: img = cv2.resize(img, (0, 0), fx=FLAGS.down_scale_factor, fy=FLAGS.down_scale_factor, interpolation=cv2.INTER_LINEAR) img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) # pad input image to avoid unmatched shape problem img, pad_params = pad_input_image(img, max_steps=max(cfg['steps'])) # run model outputs = model(img[np.newaxis, ...]).numpy() # recover padding effect outputs = recover_pad_output(outputs, pad_params) # draw and save results save_img_path = os.path.join('out_' + os.path.basename(FLAGS.img_path)) for prior_index in range(len(outputs)): draw_bbox_landm(img_raw, outputs[prior_index], img_height_raw, img_width_raw) cv2.imwrite(save_img_path, img_raw) print(f"[*] save result at {save_img_path}") else: cam = cv2.VideoCapture(FLAGS.vid_path) fps = int(cam.get(cv2.CAP_PROP_FPS)) ### Saving Video to file frame_width = int(cam.get(3)) frame_height = int(cam.get(4)) # Define the codec and create VideoWriter object.The output is stored in 'outpy.avi' file. # import os if not os.path.exists('./output'): print('Creating folder: output/ for saving video.') os.makedirs('./output') out = cv2.VideoWriter('./output/output.avi', cv2.VideoWriter_fourcc('M', 'J', 'P', 'G'), 10, (frame_width, frame_height)) start_time = time.time() counter = 0 frameCount = 0 while True: _, frame = cam.read() if frame is None: print("no cam input") frameCount = frameCount + 1 frame_height, frame_width, _ = frame.shape img = np.float32(frame.copy()) if FLAGS.down_scale_factor < 1.0: img = cv2.resize(img, (0, 0), fx=FLAGS.down_scale_factor, fy=FLAGS.down_scale_factor, interpolation=cv2.INTER_LINEAR) img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) # pad input image to avoid unmatched shape problem img, pad_params = pad_input_image(img, max_steps=max(cfg['steps'])) # run model outputs = model(img[np.newaxis, ...]).numpy() # recover padding effect outputs = recover_pad_output(outputs, pad_params) # draw results for prior_index in range(len(outputs)): croppedFace = draw_bbox_landm(frame, outputs[prior_index], frame_height, frame_width) if frameCount >= fps * FLAGS.dfps: fileName = "%d.png" % counter cv2.imwrite(FLAGS.dst_path + fileName, croppedFace) print('Saved:', fileName) counter = counter + 1 frameCount = 0 # calculate fps fps_str = "FPS: %.2f" % (1 / (time.time() - start_time)) start_time = time.time() cv2.putText(frame, fps_str, (25, 25), cv2.FONT_HERSHEY_DUPLEX, 0.75, (0, 255, 0), 2) # show frame if FLAGS.preview: cv2.imshow('frame', frame) out.write(frame) if cv2.waitKey(1) == ord('q'): exit()
def main(): # with open('/home/anhdq23/Desktop/nguyen/VT_simulation/weights/arcface_ret50.json', 'r') as f: # model_json = json.load(f) # model = model_from_json(model_json) # model.load_weights('/home/anhdq23/Desktop/nguyen/VT_simulation/weights/arcface_ret50.h5') cfg = load_yaml('./configs/arc_res50_mask.yaml') 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=False) 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.") 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) temp1 = np.ones((62, 112, 3)) temp2 = np.zeros((50, 112, 3)) masked_img = np.concatenate([temp1, temp2], axis=0) path_to_data = '/home/anhdq23/Desktop/nguyen/data/AR/test2' anchor_names = list(get_gallery_pr2(path_to_data)) # From 1 to 100 name_dicts = get_probe_pr2( path_to_data) # Dictionary: {anchor_name:[name_image, ...]} dist_all = [] labels_ARface = [] for subject in np.arange(100): tmp = np.zeros((600, )) tmp[subject * 6:subject * 6 + 6] += 1 labels_ARface.extend(list(tmp)) labels_ARface = np.array(labels_ARface) database_image_names = [] database_feature_list = [] for anchor_name in anchor_names: # Woman if anchor_name == 'W-042-01.bmp': anchor_name = 'W-042-14.bmp' if anchor_name == 'W-028-01.bmp': anchor_name = 'W-028-14.bmp' if anchor_name == 'W-025-01.bmp': anchor_name = 'W-025-14.bmp' if anchor_name == 'W-016-01.bmp': #for W7 anchor_name = 'W-016-16.bmp' if anchor_name == 'W-003-01.bmp': anchor_name = 'W-003-14.bmp' if anchor_name == 'W-050-01.bmp': anchor_name = 'W-050-03.bmp' if anchor_name == 'W-012-01.bmp': anchor_name = 'W-012-03.bmp' # Man if anchor_name == 'M-009-01.bmp': anchor_name = 'M-009-14.bmp' if anchor_name == 'M-018-01.bmp': anchor_name = 'M-018-14.bmp' if anchor_name == 'M-028-01.bmp': anchor_name = 'M-028-02.bmp' if anchor_name == 'M-043-01.bmp': anchor_name = 'M-043-15.bmp' if anchor_name == 'M-048-01.bmp': anchor_name = 'M-048-14.bmp' img1 = Image.open(os.path.join(path_to_data, anchor_name)) # img1 = expand2square(img1, (255, 255, 255)) img1 = img1.resize((112, 112)) img1 = np.array(img1) / 255.0 img1 = np.multiply(img1, masked_img) fc1 = resnet_head.predict(img1.reshape((1, 112, 112, 3))) fc1 = resnet_tail.predict(fc1) 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) print( np.array(database_feature_list).shape, database_feature_list[0].shape) # Init faiss res = faiss.StandardGpuResources() # use a single GPU index_flat = faiss.IndexFlatL2(512) # gpu_index_flat = faiss.index_cpu_to_gpu(res, 0, index_flat) 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()): print(key) 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_head.predict(img2.reshape((1, 112, 112, 3))) fc2 = resnet_tail.predict(fc2) 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 print(name, database_image_names[I[0][0]]) if name[0:5] == database_image_names[I[0][0]][0:5]: count += 1 print(count) plt.plot(dist_all) plt.show() thresholds = np.arange(0, 1, 0.01) tpr_all = [] fpr_all = [] for thr in thresholds: tpr, fpr, acc, f1 = calculate_accuracy(thr, np.array(dist_all), labels_ARface) top_left = np.sqrt((1 - tpr)**2 + fpr**2) print('thr %.4f' % thr , 'tpr %.4f' % tpr, 'fpr %.4f' % fpr, \ 'top left %.4f' % top_left, 'acc %.4f' % acc, 'f1_score %.4f'%f1) # top_left_batch.append(top_left) tpr_all.append(tpr) fpr_all.append(fpr) for threshold in thresholds: predict_issame = np.less(np.array(dist_all), threshold) conf_matrix = confusion_matrix(labels_ARface, predict_issame) print(conf_matrix) plt.figure() lw = 2 plt.plot(fpr_all, tpr_all, color='darkorange', lw=lw, label='ROC curve') plt.xlim([0.0, 1.]) plt.ylim([0.0, 1.]) plt.xlabel('False Positive Rate') plt.ylabel('True Positive Rate') plt.title('Receiver operating characteristic') plt.legend(loc="lower right") plt.show()