def __init__(self):
self.node_name = rospy.get_name()
rospy.loginfo("[%s] Initializing......" % (self.node_name))
self.bridge = CvBridge()
self.visualization = True
self.image_msg = None
self.pub_detections = rospy.Publisher("~image_face",
CompressedImage,
queue_size=1)
self.recognizer = FaceRecognizer(scale=3)
rospy.Service('~detect_face_locations', GetFaceDetections,
self.cbDetectFaceLocations)
rospy.Service('~detect_face_labels', GetFaceDetections,
self.cbDetectFaceLabels)
rospy.Service('~list_face_labels', GetStrings, self.cbListFaceLabels)
rospy.Service('~add_face_label', SetString, self.cbAddFaceLabel)
rospy.Service('~remove_face_label', SetString, self.cbRemoveFaceLabel)
# self.sub_image = rospy.Subscriber("~image_raw", Image, self.cbImg , queue_size=1)
self.sub_image = rospy.Subscriber("~image_raw/compressed",
CompressedImage,
self.cbImg,
queue_size=1)
# rospy.loginfo("[%s] wait_for_service : camera_get_frame..." % (self.node_name))
# rospy.wait_for_service('~camera_get_frame')
# self.get_frame = rospy.ServiceProxy('~camera_get_frame', GetFrame)
rospy.loginfo("[%s] Initialized." % (self.node_name))
def test_gender_recognizer(args):
print 'Identity Recognizer:'
input_shape = (args.image_size, args.image_size, args.num_channels)
print 'Input shape:', input_shape
X, y = get_30_people_chunk(args.image_path, 0, gender_label=True)
print 'images shape:', X.shape
print 'labels shape:', y.shape
identity_recognizer = FaceRecognizer(args.model_path + '_gender',
y.shape[1], input_shape,
args.num_channels)
identity_recognizer.model.compile(loss=TEST_SOFTMAX,
optimizer=TEST_SGD,
metrics=['accuracy'])
y_pred = identity_recognizer.model.predict(X)
y_pred_ct = np.argmax(y_pred, axis=1)
y_true_ct = np.argmax(y, axis=1)
acc = np.sum(y_pred_ct == y_true_ct) / y_true_ct.shape[0]
print '\tAccuracy on training data: %.4f' % acc
X_val, y_val = get_30_people_chunk(args.image_path, 1, gender_label=True)
y_pred = identity_recognizer.model.predict(X_val)
y_pred_ct = np.argmax(y_pred, axis=1)
y_true_ct = np.argmax(y_val, axis=1)
acc = np.sum(y_pred_ct == y_true_ct) / y_true_ct.shape[0]
print '\tAccuracy on validation data: %.4f' % acc
def time_fr(image_folder=None):
embedding_file = 'embeddings.npy'
if os.path.exists(embedding_file):
os.remove(embedding_file)
face_recog = FaceRecognizer(model_path='model/20180402-114759')
if image_folder is None:
image_path = 'faces.jpg'
image_paths = [image_path for i in range(10)]
else:
image_paths = os.listdir(image_folder)
image_paths = [os.path.join(image_folder, p) for p in image_paths if p.endswith('jpg')]
for i, image_path in enumerate(image_paths):
print('running: %d'%i)
image = face_recog.read_image_sp(image_path)
image = resize_image(image)
det_start = time.time()
bboxes, scores, keypoints = face_recog.detect_faces_and_keypoints(image)
det_stop = time.time()
print('detection time = ', det_stop - det_start)
if len(bboxes) == 0:
print('no face detected')
else:
rec_start = time.time()
face_patches = face_recog.prepare_image_patches(image, bboxes, 160, 20)
embeddings = face_recog.extract_embedding(face_patches)
rec_stop = time.time()
print('recognition time = ', rec_stop - rec_start)
def main(face_recognition_method: str = None):
webcam = cv.VideoCapture(0)
data_aquisition = DataAquisition(dataset_dir='images/training/',
resources_dir='resources/')
known_people = data_aquisition.create_dataset(webcam)
if len(known_people) == 1:
print('Should have any face to recognition')
return
print('Training model...')
data_aquisition.train(face_recognition_method)
print('Initialzing face recognizer...')
face_recognizer = FaceRecognizer(resources_dir='resources/',
recognizer_name=face_recognition_method)
while True:
if cv.waitKey(1) & 0xFF == ord('q'):
break
_, c_frame = webcam.read()
c_frame, face_locations, labels, factors = face_recognizer.predict(
c_frame, known_people)
cv.imshow('webcam', c_frame)
webcam.release()
cv.destroyAllWindows()
def history_recollection():
history = FaceRecognizer(user_interface)
history.build_imagecsv()
user_number = history.RecognizeFace()
user_name = history.names[user_number]
if user_name is None:
#print "did not recognize user ", user_name
chatbot_response = "I don't think we've met before, what's your name?"
user_interface.update_sprites(chatbot_response, " ".join(("Emotion: ", meeting_emotion)), " ".join(("User: "******"Unknown")), "Primary Topics: ")
user_interface.render()
text_to_speech(chatbot_response)
user_name = speech.recognize_speech()
user_interface.update_sprites(chatbot_response, " ".join(("Emotion: ", meeting_emotion)), " ".join(("User: "******"Primary Topics: ")
user_interface.render()
#print "Name entered as: ", user_name
history.retrain(user_name)
else:
#print "recognized user ", user_name
chatbot_response = "It's good to see you again, " + user_name
user_interface.update_sprites(chatbot_response, " ".join(("Emotion: ", meeting_emotion)), " ".join(("User: "******"Primary Topics: ")
user_interface.render()
text_to_speech(chatbot_response)
history.exit()
return user_name
def initialize(self):
if self.network_name == 'YOLO':
self.network = YOLO_TF()
elif self.network_name == 'SSD-brainlab':
self.brainlab_args = UpdatePredictConfiguration()
assert self.brainlab_args.batch_size == 1, 'Batch size must be 1'
self.network = BrainLabNet.BrainLabNet(self.brainlab_args,
'interactive')
self.network.start_interactive_session(self.brainlab_args)
self.faceRecognizer = FaceRecognizer()
elif self.network_name == 'SSD-mobilenet-face':
self.network = ssd_mobilenet_face_wrapper.ssd_mobilenet_face(
self.threshold)
self.faceRecognizer = FaceRecognizer()
else:
raise Exception('Network name not recognized')
def initialize(self):
if self.network_name == 'YOLO':
self.network = YOLO_TF()
elif self.network_name == 'SSD-mobilenet-face':
self.network = ssd_mobilenet_face_wrapper.ssd_mobilenet_face(
self.threshold)
self.faceRecognizer = FaceRecognizer()
else:
raise Exception('Network name not recognized')
def run_animation(self):
"""
Run the animation of the face
:return:
"""
self.runText.set("Press 'Esc' to stop")
self.rc = FaceRecognizer(self.root, self.canvas, self.runText,
self.runBtn, self.chatVar)
self.rc.start()
self.runText.set("Start Animation")
def __init__(self, url, faces_path, tolerance):
self.url = url
# load stream video
self.camera = cv2.VideoCapture(self.url)
if self.camera.isOpened() is False:
print("Error: Failed to open the video source.")
self.video_frame = self.camera.get(cv2.CAP_PROP_FRAME_COUNT)
self.video_fps = self.camera.get(cv2.CAP_PROP_FPS)
self.image_x = int(self.camera.get(cv2.CAP_PROP_FRAME_WIDTH))
self.image_y = int(self.camera.get(cv2.CAP_PROP_FRAME_HEIGHT))
self.face_recognizer = FaceRecognizer(faces_path, tolerance)
def __init__(self, args: Dict):
# todo proper handling of self.modes
self.ie = IECore()
self.modes = self.__determine_processing_mode(args)
net_face_detect = net_landmarks_detect = net_recognize_face = None
if not self.modes['detect']:
raise ValueError('detection model undefined')
# load networks from file
net_face_detect = self.__prepare_network(args['detection_model'])
# put it to corresponding class
# self.face_locator = FaceLocator(net_face_detect, args['detection_model_threshold'])
self.face_locator = FaceLocator(net_face_detect,
args['detection_model_threshold'],
NetworkType(args['detection_model']))
# setup device plugins
if next(iter(args['device'])) == 'CPU':
# CPU
self.ie.set_config(config={
"CPU_THROUGHPUT_STREAMS": "1",
"CPU_THREADS_NUM": "8",
},
device_name='CPU')
elif next(iter(args['device'])) == 'GPU':
# GPU
pass
self.ie.set_config(config={"GPU_THROUGHPUT_STREAMS": "1"},
device_name='GPU')
elif next(iter(args['device'])) == 'MYRIAD':
pass
# load to device for inferencing
self.face_locator.deploy_network(next(iter(args['device'])), self.ie)
if self.modes['landmark']:
net_landmarks_detect = self.__prepare_network(
args['landmarks_model'])
self.landmarks_locator = LandmarksLocator(net_landmarks_detect)
self.landmarks_locator.deploy_network(next(iter(args['device'])),
self.ie)
if self.modes['recognize']:
net_recognize_face = self.__prepare_network(
args['recognition_model'])
self.face_recognizer = FaceRecognizer(net_recognize_face)
self.face_recognizer.deploy_network(next(iter(args['device'])),
self.ie)
def __init__(self):
#observer = Observable()
#motion_detector = MotionObserver('Motion Detector')
#observer.register(motion_detector)
self.camera = cv2.VideoCapture(0)
time.sleep(0.5)
self.motion_detector = MotionDetector()
self.face_detector = FaceDetector()
self.face_recognizer = FaceRecognizer()
self.detectingstate = DetectingMotion(self)
self.scanningstate = Scanning(self)
self.facestate = FacialRecognition(self)
self.greetingstate = GreetRoommate(self)
self.waitingstate = WaitingForTask(self)
self.servingstate = Serving(self)
self.state = self.detectingstate
def __init__(self):
"""Initialize the AppEngine
Input: None
Output: Creates an instance of the AppEngine.
"""
# init QObject
super().__init__()
# create an instance of the database
self.database = Database('../data/face_data.db')
# ensure appropriate table is created
create_sql = "CREATE TABLE IF NOT EXISTS faces (FaceName TEXT PRIMARY KEY," \
"FaceEncodings BLOB NOT NULL)"
self.database.createDatabase(create_sql)
# create an instance of the VideoStreamer
self.videoStreamer = VideoStreamer()
# connect the VideoStreamer's newPiFrame signal to the processNewFrame method
self.videoStreamer.newPiFrame.connect(self.processNewFrame)
# create an instance of the FaceRecognizer
self.faceRecognizer = FaceRecognizer()
# bool which determines if facial recognition is performed on each incoming frame from the Pi
self.performFacialRecognition = False
# current frame sent from the Pi, used for adding a new face
self.currentFrame = None
# current face name and encodings, used for adding a new face
self.currentAddFaceName = None
self.currentAddFaceEncodings = list()
# create an instance of the AlertObserver
self.alertObserver = AlertObserver()
# bool determines if an alert has already been sent (only one is sent per application run)
self.alertSent = False
def __init__(self, detection_method, embedding_model):
''' function constructor
Constructor for FaceDetector
Args:
detection_method (DetectionMethod): Method to use for detection
embedding_model (FaceEmbeddingModelEnum): The model to use for generating
embeddings for face images
Returns:
None
'''
# load face detection engine
self.face_detection_engine = FaceDetectionEngine(detection_method)
self.face_recognizer = FaceRecognizer(embedding_model)
self.embedding_image_dimensions = get_image_dimensions_for_embedding_model(embedding_model)
self.start_time_stamp = None
self.fps_font = ImageFont.truetype(font="/usr/share/fonts/truetype/dejavu/DejaVuSansMono.ttf", size=20)
self.face_label_font = ImageFont.truetype(font="/usr/share/fonts/truetype/dejavu/DejaVuSansMono.ttf", size=20)
def run(self):
import dlib
from people import People
from gender_recognizer_tf import GenderRecognizer
from face_recognizer import FaceRecognizer
self.gender_recognizer = GenderRecognizer()
self.p = People("./known_people")
self.face_recognizer = FaceRecognizer(
self.p.people
) #this is not ok , we should pass onlu self.p as object
self.predictor = dlib.shape_predictor(
"shape_predictor_68_face_landmarks.dat")
self.fa = FaceAligner(self.predictor, desiredFaceWidth=160)
self.state = IdleState()
while True:
label, data = self.recv()
if label == 'video_feed':
frame = data[0]
face = None
aligned_image, face, rect_nums, XY = self.face_extractor(frame)
if face is None:
continue
face_locations, face_names, percent = self.face_recognizer.recognize(
face)
in_the_frame = self.__update_state(self.p.people, percent)
if (self.state.__class__ == MatchState):
path, gender, age = self.gender_recognizer.recognize(
aligned_image, face, rect_nums, XY)
self.broadcast(["Match", face, in_the_frame, gender, age])
else:
path, gender, age = self.gender_recognizer.recognize(
aligned_image, face, rect_nums, XY)
if path is None:
continue
print("FaceFinder path = " + path)
self.broadcast(["NoMatch", path])
ip_addresses = get_wifi_ip()
if len(ip_addresses) == 0:
print("Unable to fetch the IP address. Hence running the server on localhost - 127.0.0.1")
ip_addresses = tuple(["127.0.0.1"])
host = ip_addresses[0]
port = 9999
print("\n")
print("host = " + str(host))
print("port = " + str(port))
path_initializer.initialize_server_paths()
fr = FaceRecognizer(path_initializer.SERVER_KNOWN_FACES_FOLDER)
loaded_dataset_path = path_initializer.SERVER_MAIN_DATA_FOLDER + "/" + "trained_faces.pkl"
if not fr.load_from_file(loaded_dataset_path):
print("\n\nPlease wait while the server is getting initialized ...\n")
fr.train_on_folder_tree()
fr.save_to_file(loaded_dataset_path)
print("\nPress \"ctrl+c\" to stop the server")
while True:
print("\n")
print("=====================")
print("Server is running ...\n")
s = socket(AF_INET,SOCK_DGRAM)
s.bind((host,port))
def process_image(self, cv_image):
if not self.enable:
grey = cv.CreateImage(self.image_size, 8, 1)
cv.CvtColor(cv_image, grey, cv.CV_BGR2GRAY)
return grey
self.frame_count = self.frame_count + 1
haar = False
# Use HAAR if no faces are tracked yet or every 5
if (self.use_haar_only or not self.detect_box.any_trackable_faces()
) and self.auto_face_tracking:
self.detect_face(cv_image)
haar = True
elif self.frame_count % 5 == 0:
self.detect_face(cv_image)
haar = True
""" Otherwise, track the face using Good Features to Track and
Lucas-Kanade Optical Flow """
if not self.use_haar_only:
for fkey in self.detect_box.faces.keys():
face = self.detect_box.faces[fkey]
if not face.is_trackable():
continue
# Let's try to identify the person by this face.
# Note: face is of type FaceBox
x1, y1 = face.pt1[0], face.pt1[1]
x2, y2 = face.pt2[0], face.pt2[1]
pad = 10 # Just to relax the face boundary
# crop the face
face_cv_image = cv_image[y1:y2 + pad, x1:x2 + pad]
# DEBUG cv.SaveImage('/tmp/face.png', face_cv_image)
bridge = CvBridge()
r = FaceRecognizer().infer(np.asarray(face_cv_image))
face.name = r[0][0]
if not face.track_box or not self.is_rect_nonzero(
face.track_box):
face.features = []
face.update_box(face.face_box())
track_box = self.track_lk(cv_image, face)
if track_box and len(track_box) != 3:
face.update_box(track_box)
else:
face.update_box_elipse(track_box)
""" Prune features that are too far from the main cluster """
if len(face.features) > 0:
# Consider to move face class
((mean_x, mean_y, mean_z), mse_xy, mse_z,
score) = self.prune_features(
min_features=face.abs_min_features,
outlier_threshold=self.std_err_xy,
mse_threshold=self.max_mse,
face=face)
if score == -1:
face.lost_face()
continue
""" Add features if the number is getting too low """
if len(face.features) < face.min_features:
face.expand_roi = self.expand_roi_init * face.expand_roi
self.add_features(cv_image, face)
else:
face.expand_roi = self.expand_roi_init
self.detect_box.nextFrame(haar)
self.detect_box.publish_faces()
return cv_image
def __init__(self, dataset):
self.detector = FaceDetector()
self.recognizer = FaceRecognizer(dataset)
self.dataset = dataset
import os
import numpy as np
import cv2
from face_finder import FaceFinder, get_region_of_interest
from face_recognizer import FaceRecognizer
face_finder = FaceFinder()
recognizer = FaceRecognizer()
dataset_dir = os.path.join('dataset', 'train')
x_train = []
y_labels = []
label = 1
def recursive_append(path, x_train, y_labels, current_label):
for file in os.listdir(path):
filepath = os.path.join(path, file)
if os.path.isdir(filepath):
recursive_append(filepath, x_train, y_labels, current_label)
elif file.endswith('png') or file.endswith('jpg'):
image_array = cv2.imread(filepath)
image_array = cv2.cvtColor(image_array, cv2.COLOR_BGR2GRAY)
# image_array = cv2.equalizeHist(image_array)
# normalized_image_array = np.zeros(image_array.shape)
# normalized_image_array = cv2.normalize(image_array, normalized_image_array)
# while True:
# cv2.imshow('image', image_array)
# if cv2.waitKey(20) & 0xFF == ord('q'):
# break
faces = face_finder.find(image_array)
def create_faces_image():
images = cv2.imread(load_face_images())
face_recognize = FaceRecognizer(images)
face_recognize.face_recoginaze()
video_frame = input_movie.get(cv2.CAP_PROP_FRAME_COUNT)
video_fps = input_movie.get(cv2.CAP_PROP_FPS)
image_x = int(input_movie.get(cv2.CAP_PROP_FRAME_WIDTH))
image_y = int(input_movie.get(cv2.CAP_PROP_FRAME_HEIGHT))
# Create an output movie file
fourcc = cv2.VideoWriter_fourcc('M', 'P', '4', 'V')
output_file_name = os.path.splitext(args.video)[0] + '_result.mp4'
output_movie = cv2.VideoWriter(output_file_name, fourcc, video_fps,
(image_x, image_y))
# progress
progress = tqdm.tqdm(total=video_frame)
progress.set_description("{:12}".format("Initialize"))
face_recognizer = FaceRecognizer(args.face, args.tol)
frame_number = 0
progress.set_description("{:12}".format("Processing"))
while True:
# Grab a single frame of video
ret, frame = input_movie.read()
frame_number += 1
# Quit when the input video file ends
if not ret:
break
res_img = face_recognizer.recognize(frame)
parser.add_argument(
'--predictor_path',
type=str,
required=True,
help=
'location of the dlib facial landmark predictor where shape_predictor_68_face_landmarks.dat is located'
)
parser.add_argument('--gallery_path',
type=str,
required=True,
help='location of the gallery')
parser.add_argument('--port', type=int, default=8000, help='which port to use')
args = parser.parse_args()
face_aligner = FaceAligner(args.predictor_path)
face_recognizer = FaceRecognizer(args.gallery_path, OpenCVAlgorithm,
face_aligner)
register_handler = RegisterHandler(args.gallery_path, face_aligner)
recognize_handler = RecognizeHandler(args.gallery_path, face_aligner,
face_recognizer)
class S(BaseHTTPRequestHandler):
def _set_response(self, message=None):
self.send_response(200)
if message is not None:
#self.send_header('Content-type', 'text/html')
self.send_header('Content-type', 'application/json')
self.end_headers()
def do_GET(self):
def __init__(self):
self.face_finder = FaceFinder()
self.recognizer = FaceRecognizer()
self.recognizer.load('trainer.yml')
self.security_trigger = Trigger(20, lambda similarity: similarity > 80)
def train():
opt = opts.parse_opt()
opt.input_data = "MNIST"
img_size = (opt.img_dim, opt.img_dim)
print 'Dimension of images:', img_size
train_data, train_label, id_gender = \
get_30_people_chunk(opt.image_path, 1, gender_meta=True, img_size=img_size)
test_data, test_label = get_30_people_chunk(opt.image_path,
2,
img_size=img_size)
names = get_people_names(opt.image_path, 30)
if opt.balance_data:
ratio = opt.balance_ratio
print 'Balancing dataset with ratio %f' % ratio
train_data, train_label = balance_dataset(train_data, train_label)
test_data, test_label = balance_dataset(test_data, test_label)
if opt.balance_gender:
print train_data.shape, train_label.shape
print test_data.shape, test_label.shape
print 'Balancing genders'
selected_people = []
for i in range(id_gender.shape[1]):
indices, = np.where(id_gender[:, i] == 1)
selected_people.append(np.random.choice(indices, 5, replace=False))
selected_people = np.concatenate(selected_people)
print 'Selected people are:'
print np.array(names)[selected_people]
selected_imgs = train_label[:, selected_people].sum(axis=1) != 0
train_data = train_data[selected_imgs, :]
train_label = train_label[selected_imgs, :]
selected_imgs = test_label[:, selected_people].sum(axis=1) != 0
test_data = test_data[selected_imgs, :]
test_label = test_label[selected_imgs, :]
print 'Shape of data:'
print '\tTraining data: ' + str(train_data.shape)
print '\tTraining label: ' + str(train_label.shape)
print '\tMax, Min Train: %.4f, %.4f' % (np.max(train_data),
np.min(train_data))
print '\tTest data: ' + str(test_data.shape)
print '\tTest label: ' + str(test_label.shape)
print '\tMax, Min Test: %.4f, %.4f' % (np.max(test_data),
np.min(test_data))
x_dim = train_data.shape[1]
y_dim = train_label.shape[1]
opt.input_c_dim = 3
opt.output_c_dim = 3
opt.input_dim = x_dim
opt.label_dim = y_dim
input_shape = (x_dim, x_dim, opt.input_c_dim)
batch_size = opt.batch_size
print 'Batch size: %d' % batch_size
NUM_REPR = 5
NUM_SAMPLES_EACH = int(batch_size / NUM_REPR / 2)
output_samples = get_output_samples(train_data, train_label, id_gender,
NUM_REPR, NUM_SAMPLES_EACH)
NUM_THREADS = 2
tf_config = tf.ConfigProto()
tf_config.intra_op_parallelism_threads = NUM_THREADS
tf_config.gpu_options.allow_growth = True
iteration_time = []
with tf.Session(config=tf_config) as sess:
id_model_path = '%s_%d_id_0' % (opt.lfw_base_path, x_dim)
print '\tRetrieving evil model from "%s"' % id_model_path
evil_model = FaceRecognizer(id_model_path, train_label.shape[1],
input_shape, opt.input_c_dim)
gender_model_path = '%s_%d_gender_0' % (opt.lfw_base_path, x_dim)
print '\tRetrieving good model from "%s"' % gender_model_path
good_model = FaceRecognizer(gender_model_path, 2, input_shape,
opt.input_c_dim)
model = advGAN(good_model, evil_model, opt, sess, mnist=False)
iteration = 0
if opt.resnet_gen:
generator_mode = 'ResNet'
else:
generator_mode = 'Regular'
summary_dir = "logs/LFW/g_%d_ld_%d_gl_%d_L2_%.2f_lr_%.4f_%s/" % (
opt.G_lambda, opt.ld, opt.good_loss_coeff, opt.L2_lambda,
opt.learning_rate, generator_mode)
if os.path.isdir(summary_dir) is False:
print 'Creating directory %s for logs.' % summary_dir
os.mkdir(summary_dir)
# else:
# print 'Removing all files in %s' % (summary_dir + '*')
# shutil.rmtree(summary_dir)
writer = tf.summary.FileWriter(summary_dir, sess.graph)
loader = Dataset2(train_data, train_label)
print 'Training data loaded.'
print 'Maximum iterations: %d' % opt.max_iteration
max_acc_diff = -1.0
while iteration < opt.max_iteration:
# this function returns (data, label, np.array(target)).
feed_data, evil_labels, real_data = loader.next_batch(
batch_size, negative=False)
good_labels = id_gender[np.argmax(evil_labels, axis=1)]
feed = {
model.source: feed_data,
model.target: real_data,
model.good_labels: good_labels,
model.evil_labels: evil_labels
}
# Training G once.
summary_str, G_loss, _ = sess.run(
[model.total_loss_merge_sum, model.g_loss, model.G_train_op],
feed)
writer.add_summary(summary_str, iteration)
# Training G twice.
summary_str, G_loss, gan_loss, hinge_loss, l1_loss, l2_loss, \
good_fn_loss, evil_fn_loss, adv_loss, total_loss, _ = sess.run([
model.total_loss_merge_sum,
model.g_loss,
model.gan_loss,
model.hinge_loss,
model.l1_loss,
model.l2_loss,
model.good_fn_loss,
model.evil_fn_loss,
model.adv_loss,
model.total_loss,
model.G_train_op], feed)
writer.add_summary(summary_str, iteration)
# Training D.
summary_str, D_loss, _ = \
sess.run([model.total_loss_merge_sum, model.d_loss, model.D_pre_train_op], feed)
writer.add_summary(summary_str, iteration)
if iteration % opt.losses_log_every == 0:
print "iteration: ", iteration
print '\tD: %.4f, G: %.4f\n\thinge(%.2f): %.4f, L1(%.2f): %.4f, L2(%.2f): %.4f' % (
D_loss, G_loss, opt.H_lambda, hinge_loss, opt.L1_lambda,
l1_loss, opt.L2_lambda, l2_loss)
print '\t\tGAN total loss: %.4f' % gan_loss
print '\tGood: %.4f, Evil: %.4f' % (good_fn_loss, evil_fn_loss)
print '\tAdv: %.4f, Total: %.4f' % (adv_loss, total_loss)
new_test_data = []
new_pred_data = []
head = 0
last_batch = False
while head < test_data.shape[0]:
if head + batch_size <= test_data.shape[0]:
tail = head + batch_size
else:
tail = test_data.shape[0]
head = test_data.shape[0] - batch_size
last_batch = True
cur_data, pred_data = sess.run(
[model.fake_images_output, model.prediction_ready],
{model.source: test_data[head:tail, :]})
if last_batch:
new_test_data.append(
cur_data[-(test_data.shape[0] % batch_size):, :])
new_pred_data.append(
pred_data[-(test_data.shape[0] % batch_size):, :])
else:
new_test_data.append(cur_data)
new_pred_data.append(pred_data)
head += batch_size
new_test_data = np.concatenate(new_test_data)
new_pred_data = np.concatenate(new_pred_data)
good_pred = np.argmax(
model.good_model.model.predict(new_pred_data), axis=1)
evil_pred = np.argmax(
model.evil_model.model.predict(new_pred_data), axis=1)
evil_true = np.argmax(test_label, axis=1)
good_true = np.argmax(id_gender[evil_true, :], axis=1)
good_accuracy = accuracy_score(good_true, good_pred)
evil_accuracy = accuracy_score(evil_true, evil_pred)
total_good_confusion = confusion_matrix(good_true, good_pred)
total_evil_confusion = confusion_matrix(
evil_true, evil_pred, labels=range(opt.evil_label_num))
print '\tGood Accuracy: %.4f, Evil Accuracy: %.4f' % (
good_accuracy, evil_accuracy)
print '\tAccuracy diff: %f' % (good_accuracy - evil_accuracy)
print 'Good confusion matrix:'
print total_good_confusion
evil_misclass = total_evil_confusion.sum(
axis=0) - np.diag(total_evil_confusion)
evil_idxs = np.argsort(-evil_misclass)
print 'Top 3 Misclassifications:'
print np.array(names)[evil_idxs][:3]
print evil_misclass[evil_idxs][:3]
evil_tp = np.diag(total_evil_confusion)
evil_idxs = np.argsort(-evil_tp)
print 'Top 3 True classifications:'
print np.array(names)[evil_idxs][:3]
print evil_tp[evil_idxs][:3]
# print 'Selected people are:'
# print names[evil_idxs].tolist()
# print evil_tp
# print total_evil_confusion
# print evil_idxs
fake_samples, fake_noise = sess.run(
[model.fake_images_output, model.fake_noise_output],
{model.source: output_samples})
fakes = merge(fake_samples, [2 * NUM_REPR, NUM_SAMPLES_EACH])
original = merge(output_samples,
[2 * NUM_REPR, NUM_SAMPLES_EACH])
noise = merge(fake_noise, [2 * NUM_REPR, NUM_SAMPLES_EACH])
final_image = np.concatenate([fakes, noise, original], axis=1)
scipy_imsave('snapshot_%d.png' % iteration, final_image)
if (good_accuracy - evil_accuracy) > max(0.5, max_acc_diff):
print '\tSaving new training data at accuracy diff: %.4f' % (
good_accuracy - evil_accuracy),
max_acc_diff = good_accuracy - evil_accuracy
# other_good = FaceRecognizer('%s_%d_gender_0' % (opt.lfw_base_path, x_dim),
# 2, input_shape, opt.input_c_dim)
# other_pred = np.argmax(other_good.model.predict(new_pred_data), axis=1)
# print 'Other Good accuracy: %.4f' % accuracy_score(good_true, other_pred)
# other_pred = np.argmax(other_good.model.predict(
# preprocess_images(new_test_data * 255.0)), axis=1)
# print '\tTest data processeced accuracy: %.4f' % \
# accuracy_score(good_true, other_pred)
# other_evil = FaceRecognizer('%s_%d_id_0' % (opt.lfw_base_path, x_dim),
# 34, input_shape, opt.input_c_dim)
# other_pred = np.argmax(other_evil.model.predict(new_pred_data), axis=1)
# print 'Other Evil accuracy: %.4f' % accuracy_score(evil_true, other_pred)
# other_pred = np.argmax(other_evil.model.predict(
# preprocess_images(new_test_data * 255.0)), axis=1)
# print '\tTest data processeced accuracy: %.4f' % \
# accuracy_score(evil_true, other_pred)
new_train_data = []
head = 0
last_batch = False
while head < train_data.shape[0]:
if head + batch_size <= train_data.shape[0]:
tail = head + batch_size
else:
tail = train_data.shape[0]
head = train_data.shape[0] - batch_size
last_batch = True
cur_data = sess.run(
model.fake_images_output,
{model.source: train_data[head:tail, :]})
if last_batch:
new_train_data.append(
cur_data[-(train_data.shape[0] %
batch_size):, :])
else:
new_train_data.append(cur_data)
head += batch_size
new_train_data = np.concatenate(new_train_data)
np.savez_compressed(opt.output_path,
train_data=new_train_data,
org_train_data=train_data,
train_label=train_label,
test_data=new_test_data,
org_test_data=test_data,
test_label=test_label,
id_gender=id_gender)
print '\t[DONE]'
iteration += 1
def main(path, correct_label):
qr_flag = False
fr = FaceRecognizer()
video = cv2.VideoCapture(path)
width = int(video.get(cv2.CAP_PROP_FRAME_WIDTH) + 0.5)
height = int(video.get(cv2.CAP_PROP_FRAME_HEIGHT) + 0.5)
fourcc = cv2.VideoWriter_fourcc(*'mp4v')
out = cv2.VideoWriter('data/output.mp4', fourcc, 20.0, (width, height))
face_correct_cnt = 0
face_wrong_cnt = 0
face_undetected_cnt = 0
multiple_face_cnt = 0
cfd_high = 0
cnt = 0
while video.isOpened():
cnt += 1
ret, frame = video.read()
if not ret:
break
# QR code detection
if not qr_flag:
info = qr_decode(Image.fromarray(np.uint8(frame)))
if info:
print('QR code detected')
print(info)
qr_flag = True
# face recognition
faces = crop_image(frame)
if len(faces) == 1:
x, y, w, h = faces[0]
image = cv2.resize(frame[y: y + h, x: x + w], (200, 200),
interpolation=cv2.INTER_LINEAR)
image_pil = Image.fromarray(np.uint8(image)).convert('L')
image = np.array(image_pil, 'uint8')
label, cfd = fr.recognizer.predict(image)
if label != correct_label:
face_wrong_cnt += 1
else:
face_correct_cnt += 1
if cfd > 40:
cfd_high += 1
# write rectangle to indicate where the face is
color = (0, 255, 0) if label == correct_label else (0, 0, 255)
cv2.rectangle(frame, (x, y), (x+w, y+h), color, 3)
font = cv2.FONT_HERSHEY_SIMPLEX
txt = 'Ayumu' if label == correct_label else 'not Ayumu'
cv2.putText(frame, txt + '%.3f' % (cfd), (x, y), font, 1,
(255, 255, 255), 2, cv2.LINE_AA)
elif len(faces) > 1:
# print('multiple faces are detected!')
multiple_face_cnt += 1
# break
elif len(faces) == 0:
face_undetected_cnt += 1
if face_wrong_cnt > threshold:
print('face recognition failed')
print(cnt)
break
out.write(frame)
video.release()
out.release()
print('total frames', cnt)
print('correct', face_correct_cnt)
print('wrong', face_wrong_cnt)
print('undetected', face_undetected_cnt)
print('multiple', multiple_face_cnt)
def main():
parser = argparse.ArgumentParser()
parser.add_argument(
'--model_path',
type=str,
default="models/lfw",
help="Path to save trained model. e.g.: 'models/lfw'")
parser.add_argument(
'--image_path',
type=str,
default='./lfw_data/perturbed.npz',
help='Path to LFW data.')
parser.add_argument(
'--image_size', type=int, default=224, help='Size of input images.')
parser.add_argument(
'--num_channels',
type=int,
default=3,
help='Number of channels in input images.')
parser.add_argument(
'--train_new',
dest='train_new',
action='store_true',
help='Train a new classifier.')
parser.set_defaults(train_new=False)
args = parser.parse_args()
input_shape = (args.image_size, args.image_size, args.num_channels)
data = np.load(args.image_path)
id_gender = data['id_gender']
org_train_data = data['org_train_data']
train_data = data['train_data']
train_id = np.argmax(data['train_label'], axis=1)
train_gender = np.argmax(id_gender[train_id, :], axis=1)
test_data = data['test_data']
org_test_data = data['org_test_data']
test_id = np.argmax(data['test_label'], axis=1)
test_gender = np.argmax(id_gender[test_id, :], axis=1)
num_good_labels = 2
num_evil_labels = data['train_label'].shape[1]
print train_data.shape
print train_data.min(), train_data.max()
print org_train_data.shape
print org_train_data.min(), org_train_data.max()
print test_data.shape
print test_data.min(), test_data.max()
print org_test_data.shape
print org_test_data.min(), org_test_data.max()
print 'Preprocessing data:',
for cur_data in [org_train_data, train_data, org_test_data, test_data]:
cur_data = preprocess_images(cur_data * 255.0, version=1)
print '[DONE]'
good_used = FaceRecognizer('%s_%d_gender_0' % (args.model_path,
args.image_size),
num_good_labels, input_shape)
good_left = FaceRecognizer('%s_%d_gender_1' % (args.model_path,
args.image_size),
num_good_labels, input_shape)
evil_used = FaceRecognizer('%s_%d_id_0' % (args.model_path,
args.image_size),
num_evil_labels, input_shape)
evil_left = FaceRecognizer('%s_%d_id_1' % (args.model_path,
args.image_size),
num_evil_labels, input_shape)
for model, label, name in zip(
[evil_used, good_used, evil_left, good_left],
[test_id, test_gender, test_id, test_gender],
['Used Evil', 'Used Good', 'Left-out Evil', 'Left-out Good']):
print name + ':'
org_pred = np.argmax(model.model.predict(org_test_data), axis=1)
org_acc = accuracy_score(label, org_pred)
print '\tOriginal Accuracy: %.4f' % org_acc
dst_pred = np.argmax(model.model.predict(test_data), axis=1)
dst_acc = accuracy_score(label, dst_pred)
print '\tPerturbed Accuracy: %.4f' % dst_acc
if args.train_new:
# Train a new classifier with the new training data, test with original test data.
raise NotImplementedError(
'Training new classifier is not yet implemented.')
import cv2
import numpy as np
from fastapi import FastAPI, File
from face_recognizer import FaceRecognizer
face_rec = FaceRecognizer()
face_rec.create_known_faces('data/mask_nomask')
app = FastAPI()
@app.get("/")
def root():
return {"message": "Hello World"}
@app.post("/update")
def update():
face_rec.create_known_faces('data/mask_nomask')
return {"result": 'ok'}
@app.post("/file")
def file(file: bytes = File(...)):
image_array = np.frombuffer(file, dtype=np.uint8) # numpy array
img = cv2.imdecode(image_array, cv2.COLOR_RGBA2BGR)
result = face_rec.recognize(img)
return {"result": result}
def __init__(self):
self._load_dataset_index()
self.face_recognizer = FaceRecognizer(test_model_weight_path)
from face_recognizer import FaceRecognizer
fce = FaceRecognizer()
# name of the person to be deleted
fce.delete_a_face('mals')
