def get_lane_pixels_bgr( frame, mtx, dist, persp_m ) :
"""Convert from bgr to rgb, yndistort, perspective correct and get lane pixels"""
distorted = u.bgr2rgb( frame )
undistorted = cv2.undistort(distorted, mtx, dist, None, mtx)
warped = warp_perspective(undistorted, persp_m )
return warped, undistorted, get_lane_pixels_0( undistorted )
def align_face(self, img_bgr, bbox):
if config.landmarks == 'outerEyesAndNose':
landmarkIndices = AlignDlib.OUTER_EYES_AND_NOSE
elif config.landmarks == 'innerEyesAndBottomLip':
landmarkIndices = AlignDlib.INNER_EYES_AND_BOTTOM_LIP
elif config.landmarks == 'outerEyes':
landmarkIndices = AlignDlib.OUTER_EYES
else:
landmarkIndices = AlignDlib.INNER_EYES_AND_NOSE_AND_LIP_CORNER
print landmarkIndices
img_rgb = util.bgr2rgb(img_bgr)
return self.__align.align(config.face_size,
img_rgb,
bbox,
ts=config.ts,
landmarkIndices=landmarkIndices)
id2url_file = sys.argv[3].strip()
with open(id2url_file, 'r') as reader:
lines = reader.readlines()
for line in lines:
segs = line.strip().split('\t')
id = segs[0].strip()
url = segs[1].strip()
id2url[id] = url
feature_extractor = CnnFeatureExtractor(config.alexnet_config)
db_folder = sys.argv[1].strip()
db_files = [db_file for db_file in os.listdir(db_folder)]
db_binary_features = []
for db_file in db_files:
img_bgr = cv2.imread(os.path.join(db_folder, db_file))
img_rgb = util.bgr2rgb(img_bgr)
db_binary_features.append(
feature_extractor.extract_binary_feature(img_rgb))
assert len(db_files) == len(db_binary_features)
print 'Totally', len(db_files), 'db images.'
in_folder = sys.argv[2].strip()
in_files = [in_file for in_file in os.listdir(in_folder)]
in_binary_features = []
for in_file in in_files:
img_bgr = cv2.imread(os.path.join(in_folder, in_file))
img_rgb = util.bgr2rgb(img_bgr)
in_binary_features.append(
feature_extractor.extract_binary_feature(img_rgb))
assert len(in_files) == len(in_binary_features)
print 'Totally', len(in_files), 'test images.'
def detect_largest_face(self, img_bgr):
img_rgb = util.bgr2rgb(img_bgr)
return self.__align.getLargestFaceBoundingBox(img_rgb)
def detect_all_faces(self, img_bgr):
img_rgb = util.bgr2rgb(img_bgr)
return self.__align.getAllFaceBoundingBoxes(img_rgb)
def train():
print(args)
if not os.path.exists(args.logdir):
os.makedirs(args.logdir)
os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu
np.random.seed(args.seed)
tf.set_random_seed(args.seed)
with open(os.path.join(args.logdir, 'args'), 'w') as f:
for k, v in vars(args).items():
f.write(k + ':' + str(v))
net = deepSimNet(args.batch_size, args.recon_w, args.feat_w, args.dis_w,
args.gan)
data = util.DataFetcher(args.imdb_name)
sess = tf.Session()
# global step
global_step = tf.contrib.framework.get_or_create_global_step()
incr_global_step = tf.assign(global_step, global_step + 1)
# learning rate after decay
learning_rate = tf.train.exponential_decay(args.lr,
global_step,
100000,
args.lrd,
staircase=True)
# optimizer and train op
if args.optimizer == 'RMS':
G_optimizer = tf.train.RMSPropOptimizer(learning_rate,
decay=args.beta1)
D_optimizer = tf.train.RMSPropOptimizer(learning_rate * 0.1,
decay=args.beta1)
elif args.optimizer == 'Adam':
G_optimizer = tf.train.AdamOptimizer(learning_rate, beta1=args.beta1)
D_optimizer = tf.train.AdamOptimizer(learning_rate * 0.1,
beta1=args.beta1)
gen_grads = G_optimizer.compute_gradients(net.gen_loss, net.gen_variables)
gen_train_op = G_optimizer.apply_gradients(gen_grads)
dis_grads = D_optimizer.compute_gradients(net.dis_loss, net.dis_variables)
dis_train_op = D_optimizer.apply_gradients(dis_grads)
# clip op
if args.gan == 'wgan':
clip_disc_op = [
var.assign(tf.clip_by_value(var, args.clip0, args.clip1))
for var in net.dis_variables
]
print('Initializing net, saver and tf...')
sess.run(tf.global_variables_initializer())
# restore the encoder model
try:
saver = tf.train.Saver(net.enc_variables)
saver.restore(sess, tf.train.latest_checkpoint(args.encoder))
except:
raise Exception(
'fail to restore encoder. please check your encoder model')
saver = tf.train.Saver(max_to_keep=None)
ckpt = tf.train.get_checkpoint_state(args.logdir)
if ckpt and ckpt.model_checkpoint_path:
saver.restore(sess, ckpt.model_checkpoint_path)
print('deepSimNet restored..')
# summary information and handler
for grad, var in gen_grads:
tf.summary.histogram('generator/' + var.name + '/grad', grad)
tf.summary.histogram('generator/' + var.name, var)
for grad, var in dis_grads:
tf.summary.histogram('discriminator/' + var.name + '/grad', grad)
tf.summary.histogram('discriminator/' + var.name, var)
tf.summary.scalar('gen_loss', net.gen_loss)
tf.summary.scalar('dis_loss', net.dis_loss)
tf.summary.scalar('G/gen_dis_loss', net.gen_dis_loss)
tf.summary.scalar('G/recon_loss', net.recon_loss)
tf.summary.scalar('G/feat_loss', net.feat_loss)
tf.summary.scalar('real_score', tf.reduce_mean(net.real_score_logit))
tf.summary.scalar('fake_score', tf.reduce_mean(net.fake_score_logit))
tf.summary.image('real_image', util.bgr2rgb(util.invprep(net.real_image)))
tf.summary.image('fake_image', util.bgr2rgb(util.invprep(net.fake_image)))
summary_op = tf.summary.merge_all()
summary_writer = tf.summary.FileWriter(args.logdir, sess.graph)
# tf process initialization
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess, coord)
tic = time.time()
try:
for step in range(1, args.iters + 1):
tic_ = time.time()
noise_sigma = 2 / 256.0 * (1 - step / 500000.0)
blobs = data.nextbatch(args.batch_size)
feed_dict = {
net.original_image: blobs['data'],
net.noise_sigma: noise_sigma
}
run_dict = {}
run_dict['global_step'] = global_step
run_dict['incr_global_step'] = incr_global_step
run_dict['gen_train_op'] = gen_train_op
if args.debug:
run_dict['gen_grads'] = gen_grads
run_dict['dis_grads'] = dis_grads
if step % args.show_freq == 0:
run_dict['dis_loss'] = net.dis_loss
run_dict['gen_dis_loss'] = net.gen_dis_loss
run_dict['recon_loss'] = net.recon_loss
run_dict['feat_loss'] = net.feat_loss
if step % args.summ_freq == 0:
run_dict['summary'] = summary_op
# run gen_train_op and other necessary information
results = sess.run(run_dict, feed_dict=feed_dict)
# run dis_train_op only
if args.gan == 'wgan':
for i in range(args.critic_iters): # for WGAN train
sess.run([dis_train_op, clip_disc_op], feed_dict=feed_dict)
blobs = data.nextbatch(args.batch_size)
feed_dict = {
net.original_image: blobs['data'],
net.noise_sigma: noise_sigma
}
elif args.gan == 'lsgan' or args.gan == 'gan':
sess.run(dis_train_op, feed_dict=feed_dict)
# save, summary and display
if step % args.show_freq == 0:
rate = step / (time.time() - tic)
remaining = (args.iters + 1 - step) / rate
print(
' step %6d , dis_loss: %3f , gen_dis_loss: %3f , recon_loss: %3f , feat_loss: %3f, remaining %5dm'
% (results['global_step'], results['dis_loss'],
results['gen_dis_loss'], results['recon_loss'],
results['feat_loss'], remaining / 60))
if step % args.save_freq == 0:
print('================ saving model =================')
saver.save(sess,
os.path.join(args.logdir, 'model'),
global_step=results['global_step'])
if step % args.summ_freq == 0:
print('-------------- recording summary --------------')
summary_writer.add_summary(results['summary'],
results['global_step'])
except KeyboardInterrupt:
print('End Training...')
finally:
coord.request_stop()
coord.join(threads)
return feature.copy()
def extract_binary_feature(self, img_rgb):
self.forward(img_rgb)
binary_feature = self.__net.blobs[
self.config['binary_feature_layer_name']].data[0]
return binary_feature.copy() > self.config['binary_threshold']
if __name__ == '__main__':
import sys
if len(sys.argv) != 3:
print 'Usage: python extract_feature.py [img_file1] [img_file2]'
sys.exit(-1)
import cv2
import util
import config
extractor = FeatureExtractor(config.alexnet_config)
img_file1 = sys.argv[1].strip()
img_file2 = sys.argv[2].strip()
img_bgr1 = cv2.imread(img_file1)
img_bgr2 = cv2.imread(img_file2)
img_rgb1 = util.bgr2rgb(img_bgr1)
img_rgb2 = util.bgr2rgb(img_bgr2)
binary_feature1 = extractor.extract_binary_feature(img_rgb1)
binary_feature2 = extractor.extract_binary_feature(img_rgb2)
print util.hamming_distance(binary_feature1, binary_feature2)