Esempio n. 1
0
                    summary.add_summary(summary_op_val, count)

                # save ckpt files
                if count > 0 and count % args.ckpt_interval == 0:
                    filename = 'InsightFace_iter_{:d}'.format(count) + '.ckpt'
                    filename = os.path.join(args.ckpt_path, filename)
                    saver.save(sess, filename)

                # validate
                if count > 0 and count % args.validate_interval == 0:
                    feed_dict_test = {dropout_rate: 1.0}
                    feed_dict_test.update(tl.utils.dict_to_one(net.all_drop))
                    results = ver_test(ver_list=ver_list,
                                       ver_name_list=ver_name_list,
                                       nbatch=count,
                                       sess=sess,
                                       embedding_tensor=embedding_tensor,
                                       batch_size=args.batch_size,
                                       feed_dict=feed_dict_test,
                                       input_placeholder=images)
                    print('test accuracy is: ', str(results[0]))
                    total_accuracy[str(count)] = results[0]
                    log_file.write('########' * 10 + '\n')
                    log_file.write(','.join(list(total_accuracy.keys())) +
                                   '\n')
                    log_file.write(','.join(
                        [str(val)
                         for val in list(total_accuracy.values())]) + '\n')
                    log_file.flush()
                    if max(results) > 0.996:
                        print('best accuracy is %.5f' % max(results))
                        filename = 'InsightFace_iter_best_{:d}'.format(
    ver_name_list.append(opt.dataset_name)

    images = tf.placeholder(tf.float32, [None, 112, 112, 3], name='image_inputs')
    labels = tf.placeholder(tf.int64,   [None, ], name='labels_inputs')
    w_init_method = tf.contrib.layers.xavier_initializer(uniform=False)
    num_classes = opt.num_classes

    emb = resnet50(images, is_training=True)
    emb = tf.contrib.layers.flatten(emb)
    logit = arcface_loss(embedding=emb, labels=labels, w_init=w_init_method, out_num=num_classes)
    # inference_loss = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(logits=logit, labels=labels))

    var_list = tf.trainable_variables()
    g_list = tf.global_variables()
    bn_moving_vars = [g for g in g_list if 'moving_mean' in g.name]
    bn_moving_vars += [g for g in g_list if 'moving_variance' in g.name]
    var_list += bn_moving_vars

    config = tf.ConfigProto()
    config.allow_soft_placement = True
    config.gpu_options.allow_growth = True

    counter = 0
    saver = tf.train.Saver(var_list=var_list)
    with tf.Session(config=config) as sess:
    	saver.restore(sess, opt.face_ckpt)
    	feed_dict = {}

    	results = ver_test(ver_list=ver_list, ver_name_list=ver_name_list, nbatch=0, sess=sess, embedding_tensor=emb, 
    		batch_size=32, feed_dict=feed_dict, input_placeholder=images)
    	print(results)
                          'loss: [%.2f, %.2f], training accuracy is %.6f, time %.3f samples/sec' %
                          (i, count, total_loss_gpu_1, total_loss_gpu_2, inference_loss_val_gpu_1, inference_loss_val_gpu_2,
                           wd_loss_val_gpu_1, wd_loss_val_gpu_2, acc_val, pre_sec))
                count += 1

                # save summary
                if count > 0 and count % args.summary_interval == 0:
                    feed_dict = {images: images_train, labels: labels_train, dropout_rate: 0.4}
                    summary_op_val = sess.run(summary_op, feed_dict=feed_dict)
                    summary.add_summary(summary_op_val, count)

                # save ckpt files
                if count > 0 and count % args.ckpt_interval == 0:
                    filename = 'InsightFace_iter_{:d}'.format(count) + '.ckpt'
                    filename = os.path.join(args.ckpt_path, filename)
                    saver.save(sess, filename)
                # # validate
                if count >= 0 and count % args.validate_interval == 0:
                    feed_dict_test ={dropout_rate: 1.0}
                    results = ver_test(ver_list=ver_list, ver_name_list=ver_name_list, nbatch=count, sess=sess,
                             embedding_tensor=embedding_tensor, batch_size=args.batch_size//args.num_gpus, feed_dict=feed_dict_test,
                             input_placeholder=images_test)
                    if max(results) > 0.998:
                        print('best accuracy is %.5f' % max(results))
                        filename = 'InsightFace_iter_best_{:d}'.format(count) + '.ckpt'
                        filename = os.path.join(args.ckpt_path, filename)
                        saver.save(sess, filename)
            except tf.errors.OutOfRangeError:
                print("End of epoch %d" % i)
                break
Esempio n. 4
0
                    summary_op_val = sess.run(summary_op, feed_dict=feed_dict)
                    summary.add_summary(summary_op_val, count)

                # save ckpt files
                if count > 0 and count % ckpt_count_interval == 0:
                    filename = 'InsightFace_iter_' + str(count) + '-' + str(
                        i) + '.ckpt'
                    filename = os.path.join(ckpt_path, filename)
                    saver.save(sess, filename)
                # # validate
                if count >= 0 and count % validate_interval == 0:
                    feed_dict_test = {dropout_rate: 1.0}
                    results = ver_test(ver_list=ver_list,
                                       ver_name_list=ver_name_list,
                                       nbatch=count,
                                       sess=sess,
                                       embedding_tensor=embedding_tensor,
                                       batch_size=batch_size // len(num_gpus),
                                       feed_dict=feed_dict_test,
                                       input_placeholder=images_test
                                       )  # MGPU 增加////len(num_gpus)
                    if max(results) > 0.998:
                        print('best accuracy is %.5f' % max(results))
                        filename = 'InsightFace_iter_best_{:d}'.format(
                            count) + '.ckpt'
                        filename = os.path.join(ckpt_path, filename)
                        saver.save(sess, filename)
            except tf.errors.OutOfRangeError:
                print("End of epoch %d" % i)
                break