class App(object): def __init__( self, video_src, dataset_fn, face_sz=(130, 130), cascade_fn="/home/philipp/projects/opencv2/OpenCV-2.3.1/data/haarcascades/haarcascade_frontalface_alt2.xml" ): self.face_sz = face_sz self.cam = create_capture(video_src) ret, self.frame = self.cam.read() self.detector = CascadedDetector(cascade_fn=cascade_fn, minNeighbors=5, scaleFactor=1.1) # define feature extraction chain & and classifier) feature = ChainOperator(TanTriggsPreprocessing(), LBP()) classifier = NearestNeighbor(dist_metric=ChiSquareDistance()) # build the predictable model self.predictor = PredictableModel(feature, classifier) # read the data & compute the predictor self.dataSet = DataSet(filename=dataset_fn, sz=self.face_sz) self.predictor.compute(self.dataSet.data, self.dataSet.labels) def run(self): while True: ret, frame = self.cam.read() # resize the frame to half the original size img = cv2.resize(frame, (frame.shape[1] / 2, frame.shape[0] / 2), interpolation=cv2.INTER_CUBIC) imgout = img.copy() for i, r in enumerate(self.detector.detect(img)): x0, y0, x1, y1 = r # get face, convert to grayscale & resize to face_sz face = img[y0:y1, x0:x1] face = cv2.cvtColor(face, cv2.COLOR_BGR2GRAY) face = cv2.resize(face, self.face_sz, interpolation=cv2.INTER_CUBIC) # get a prediction prediction = self.predictor.predict(face)[0] # draw the face area cv2.rectangle(imgout, (x0, y0), (x1, y1), (0, 255, 0), 2) # draw the predicted name (folder name...) draw_str(imgout, (x0 - 20, y0 - 20), self.dataSet.names[prediction]) cv2.imshow('videofacerec', imgout) # get pressed key ch = cv2.waitKey(10) if ch == 27: break
class App(object): def __init__(self, video_src, dataset_fn, face_sz=(130,130), cascade_fn=join(curpath, 'haarcascade_frontalface_alt2.xml')): self.face_sz = face_sz self.cam = create_capture(video_src) ret, self.frame = self.cam.read() self.detector = CascadedDetector(cascade_fn=cascade_fn, minNeighbors=5, scaleFactor=1.1) # define feature extraction chain & and classifier) feature = ChainOperator(TanTriggsPreprocessing(), LBP()) classifier = NearestNeighbor(dist_metric=ChiSquareDistance()) # build the predictable model self.predictor = PredictableModel(feature, classifier) # read the data & compute the predictor self.dataSet = DataSet(filename=dataset_fn,sz=self.face_sz) self.predictor.compute(self.dataSet.data,self.dataSet.labels) def run(self): while True: ret, frame = self.cam.read() # resize the frame to half the original size img = cv2.resize(frame, (frame.shape[1]/2, frame.shape[0]/2), interpolation = cv2.INTER_CUBIC) imgout = img.copy() for i,r in enumerate(self.detector.detect(img)): x0,y0,x1,y1 = r # get face, convert to grayscale & resize to face_sz face = img[y0:y1, x0:x1] face = cv2.cvtColor(face,cv2.COLOR_BGR2GRAY) face = cv2.resize(face, self.face_sz, interpolation = cv2.INTER_CUBIC) # get a prediction prediction = self.predictor.predict(face) # draw the face area cv2.rectangle(imgout, (x0,y0),(x1,y1),(0,255,0),2) # draw the predicted name (folder name...) draw_str(imgout, (x0-20,y0-20), self.dataSet.names[prediction]) cv2.imshow('videofacerec', imgout) # get pressed key ch = cv2.waitKey(10) if ch == 27: break
def test_one_method(input_faces, test_faces, feature, classifier, chain=True): if chain: feature = ChainOperator(TanTriggsPreprocessing(), feature) model = PredictableModel(feature, classifier) id_list, face_list = zip(*input_faces) start = time.clock() model.compute(face_list, id_list) stop = time.clock() training_time = stop-start res_list = [] start = time.clock() for id, image in test_faces: res = model.predict(image) res_list.append([id]+res) stop = time.clock() predict_time = stop-start return (training_time, predict_time, res_list)
def checkFace(origin_img): #To do model = PredictableModel(Fisherfaces(), NearestNeighbor()) result_name = 'unknown' [X,y,subject_names] = read_images(path) list_of_labels = list(xrange(max(y)+1)) subject_dictionary = dict(zip(list_of_labels, subject_names)) model.compute(X,y) gray = cv2.cvtColor(origin_img, cv2.COLOR_BGR2GRAY) sampleImage = cv2.resize(gray, (256,256)) [ predicted_label, generic_classifier_output] = model.predict(sampleImage) print [ predicted_label, generic_classifier_output] if int(generic_classifier_output['distances']) <= 700: result_name = str(subject_dictionary[predicted_label]) return result_name
model = PredictableModel(feature=feature, classifier=classifier) # Compute the Fisherfaces on the given data (in X) and labels (in y): #--------------------------------------------- # print "Generating model" if(not os.path.exists("./temp/mymodel")): model.compute(X, y) save_model("./temp/mymodel", model) #saving model here - CHANGE THIS exit() # print "loading model" model = load_model("./temp/mymodel") # print "loaded model" urlForImage = sys.argv[2] tmpfilename = "./temp/"+str(urlForImage.split('/')[-1]) #saving image here - CHANGE THIS urllib.urlretrieve(urlForImage, tmpfilename) im = Image.open(tmpfilename) #add rotate of 90? Don't think so. im = im.resize((648,486), Image.ANTIALIAS) im = im.convert("L") # print "hello",str(im.size) im.show() to_predict_x = np.asarray(im, dtype=np.uint8) li=model.predict(to_predict_x) if(int(li[1]['distances'])<10000): # print str(li) # print str(d) print str(d[li[0]]) # print "Authenticated as ",str(li[0]),":",str(d[li[0]])," with distance : ",str(li[1]['distances']) #set threshold as 10000 else: print '-1' # print "Could not Authenticate with distance : ",str(li[1]['distances'][0])," for ",str(li[0]),":",str(d[li[0]])
model.compute(X, y) logger.debug(model) # Then turn the first (at most) 16 eigenvectors into grayscale # images (note: eigenvectors are stored by column!) E = [] for i in xrange(min(model.feature.eigenvectors.shape[1], 16)): e = model.feature.eigenvectors[:, i].reshape(X[0].shape) E.append(minmax_normalize(e, 0, 255, dtype=np.uint8)) # Plot them and store the plot to "fisherfaces.png" subplot(title="Fisherfaces", images=E, rows=4, cols=4, sptitle="Fisherface", colormap=cm.jet, filename="fisherfaces.png") logger.debug("Iniciando teste.") [images_test, labels_test] = read_images(database_path, None, None, False) i = 0 rate = 0 for im_test in images_test: prediction = model.predict(im_test) if prediction[0] == labels_test[i]: rate += 1 i += 1 classification_rate = rate * 100.0 / i error = 100 - classification_rate logger.debug("Classification rate: %f%%", classification_rate)
handler = logging.StreamHandler(sys.stdout) formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') handler.setFormatter(formatter) # Add handler to facerec modules, so we see what's going on inside: logger = logging.getLogger("facerec") logger.addHandler(handler) logger.setLevel(logging.DEBUG) # Define the Fisherfaces as Feature Extraction method: feature = Fisherfaces() # Define a 1-NN classifier with Euclidean Distance: classifier = NearestNeighbor(dist_metric=EuclideanDistance(), k=1) # Define the model as the combination model = PredictableModel(feature=feature, classifier=classifier) # Compute the Fisherfaces on the given data (in X) and labels (in y): model.compute(X, y) prediction = model.predict(X) predicted_label = prediction[0] classifier_output = prediction[1] distance = classifier_output['distances'][0] print distance E = [] for i in xrange(min(model.feature.eigenvectors.shape[1], 16)): e = model.feature.eigenvectors[:,i].reshape(X[0].shape) E.append(minmax_normalize(e,0,255, dtype=np.uint8)) # Plot them and store the plot to "python_fisherfaces_fisherfaces.pdf" subplot(title="Fisherfaces", images=E, rows=4, cols=4, sptitle="Fisherface", colormap=cm.jet, filename="fisherfaces.png") # Perform a 10-fold cross validation cv = KFoldCrossValidation(model, k=10) cv.validate(X, y)
model = PredictableModel(feature=feature, classifier=classifier) # Compute the Fisherfaces on the given data (in X) and labels (in y): model.compute(X, y) # Then turn the first (at most) 16 eigenvectors into grayscale # images (note: eigenvectors are stored by column!) # E = [] # for i in xrange(min(model.feature.eigenvectors.shape[1], 16)): # e = model.feature.eigenvectors[:, i].reshape(X[0].shape) # E.append(minmax_normalize(e, 0, 255, dtype=np.uint8)) img_path = 'rawand1.jpg' coverted_img_path = "temp_%s" % img_path detect_face(img_path,outfile=coverted_img_path) img = Image.open(coverted_img_path) img = img.convert("L") p = model.predict(img)[0] label = keys[p] print label [X, y, keys] = read_images("../faces2/", keys=keys) model.classifier.update(X,y) p = model.predict(img)[0] label = keys[p] print label
print "Train the model" start = time.clock() # model.compute(X, y) model.compute(face_list, id_list) stop = time.clock() print "Training done in", stop - start, " next...find a face" target = "10.bmp" if len(sys.argv) > 3: target = sys.argv[3] fp = utils.FaceProcessor() while target != "quit": # prufu_mynd = Image.open(os.path.join(path, target)) prufu_mynd = cv2.imread(os.path.join(path, target)) print "Nota mynd: ", os.path.join(path, target) if prufu_mynd is not None: prufu_mynd = fp.process_image(prufu_mynd) if prufu_mynd is None: print "fann ekkert andlit!" else: start = time.clock() # res = model.predict(td) res = model.predict(prufu_mynd) stop = time.clock() print res print "time: ", stop - start target = raw_input("Naesta mynd eda quit:")
# load a dataset (e.g. AT&T Facedatabase) dataSet = DataSet("/root/libface/img/yalefaces") # define Fisherfaces as feature extraction method feature = Fisherfaces() # define a 1-NN classifier with Euclidean Distance classifier = NearestNeighbor(dist_metric=EuclideanDistance(), k=1) # define the model as the combination model = PredictableModel(feature=feature, classifier=classifier) # show fisherfaces model.compute(dataSet.data, dataSet.labels) #try to recgonize im = Image.open("/root/libface/img/reg.jpg") im = im.convert("L") ar = [] ar.append(np.asarray(im, dtype=np.uint8)) print(dataSet.names[model.predict(ar)]) # turn the first (at most) 16 eigenvectors into grayscale # images (note: eigenvectors are stored by column!) """ E = [] for i in xrange(min(model.feature.eigenvectors.shape[1], 16)): e = model.feature.eigenvectors[:,i].reshape(dataSet.data[0].shape) E.append(minmax_normalize(e,0,255, dtype=np.uint8)) # plot them and store the plot to "python_fisherfaces_fisherfaces.pdf" subplot(title="Fisherfaces", images=E, rows=4, cols=4, sptitle="Fisherface", colormap=cm.jet, filename="fisherfaces.pdf") # perform a 10-fold cross validation cv = KFoldCrossValidation(model, k=10) cv.validate(dataSet.data, dataSet.labels) print cv """
# If we're learning, skip back to the top of the loop # continue # # If we don't have anything in the database, skip the recognition part # if X == []: break; # # Do we recognize the current face? # The "predict" method will return the closest match of the current image to the database # finalimage = sampleImage & facefilter [ predicted_label, generic_classifier_output] = model.predict(finalimage) # # Determine if the prediction is within a certain "threshold". This is actually the # "distance" between the image and the database. The closer the distance is to "0", the # closer a match it really is. # # Higher thresholds result in less accuracy or more mis-identified pictures. # if int(generic_classifier_output['distances'][0]) > current_threshold * 4: high=current_threshold * 4 else: high=int(generic_classifier_output['distances'][0]) # # The percentage is calculated to tell us how close we are to a perfect match we have to the current image
def run(): # This is where we write the images, if an output_dir is given # in command line: # out_dir = None # You'll need at least a path to your image data, please see # the tutorial coming with this source code on how to prepare # your image data: # if len(sys.argv) < 2: # print ("USAGE: facerec_demo.py </path/to/images>") # sys.exit() # Now read in the image data. This must be a valid path! # [X,y] = read_images(sys.argv[1]) [X, y] = read_images('../data/trainset/') # dataset = FilesystemReader(sys.argv[1]) # Then set up a handler for logging: handler = logging.StreamHandler(sys.stdout) formatter = logging.Formatter( '%(asctime)s - %(name)s - %(levelname)s - %(message)s') handler.setFormatter(formatter) # Add handler to facerec modules, so we see what's going on inside: logger = logging.getLogger("facerec") logger.addHandler(handler) logger.setLevel(logging.DEBUG) # Define the Fisherfaces as Feature Extraction method: feature = Fisherfaces() # Define a 1-NN classifier with Euclidean Distance: svm = SVM(C=0.1, kernel='rbf', degree=4, gamma='auto', coef0=0.0) knn = NearestNeighbor(dist_metric=EuclideanDistance(), k=1) # # Define the model as the combination model_svm = PredictableModel(feature=feature, classifier=svm) model_knn = PredictableModel(feature=feature, classifier=knn) # # Compute the Fisherfaces on the given data (in X) and labels (in y): model_svm.compute(X, y) model_knn.compute(X, y) # E = [] # for i in range(min(model.feature.eigenvectors.shape[1], 16)): # e = model.feature.eigenvectors[:,i].reshape(X[0].shape) # E.append(minmax_normalize(e,0,255, dtype=np.uint8)) # subplot(title="Fisherfaces", images=E, rows=4, cols=4, sptitle="Fisherface", colormap=cm.jet, filename="fisherfaces.png") # cv = LeaveOneOutCrossValidation(model) # print(cv0) # cv0.validate(dataset.data,dataset.classes,print_debug=True) cv_svm = KFoldCrossValidation(model_svm, k=10) cv_knn = KFoldCrossValidation(model_knn, k=10) param_grid = [ { 'C': [0.05, 0.1, 0.3, 0.5, 1, 2, 5], 'gamma': [0.001, 0.0001], 'kernel': ['rbf'] }, ] [tX, tY] = read_images('../data/testset/') # cv_svm.validate(X, y) # cv_knn.validate(X, y) gs(model_svm, X, y, param_grid) count1 = 0 count2 = 0 for i in range(len(tY)): r1 = model_svm.predict(tX[i]) r2 = model_knn.predict(tX[i]) if r1[0] == tY[i]: count1 += 1 if r2[0] == tY[i]: count2 += 1 print('SVM ACC:{0}'.format(count1 / len(tY))) print('KNN ACC:{0}'.format(count2 / len(tY))) print(cv_knn.print_results()) print(cv_svm.print_results())
class FaceDatabase(object): def __init__(self, database_folder, feature_parameter="LPQ", metric="chi", k=3): self.model = None handler = logging.StreamHandler(sys.stdout) formatter = logging.Formatter( '%(asctime)s - %(name)s - %(levelname)s - %(message)s') handler.setFormatter(formatter) logger = logging.getLogger("facerec") logger.addHandler(handler) logger.setLevel(logging.DEBUG) path = database_folder start = time.clock() input_faces = utils.read_images_from_single_folder(path) stop = time.clock() print("read {}, images from {} in {} seconds.".format( len(input_faces), path, stop - start)) feature = None m = { "fisher": Fisherfaces, "fisher80": Fisherfaces, "pca": PCA, "pca10": PCA, "lda": LDA, "spatial": SpatialHistogram, "LPQ": SpatialHistogram } if feature_parameter in m: if feature_parameter == 'LPQ': feature = SpatialHistogram(LPQ()) self.threshold = threshold_function(71.4, 70) elif feature_parameter == 'fisher80': feature = Fisherfaces(80) self.threshold = threshold_function(0.61, 0.5) elif feature_parameter == 'fisher': feature = Fisherfaces() self.threshold = threshold_function(0.61, 0.5) elif feature_parameter == 'pca80': feature = PCA(80) else: feature = m[feature_parameter]() metric_param = None d = { "euclid": EuclideanDistance, "cosine": CosineDistance, "normal": NormalizedCorrelation, "chi": ChiSquareDistance, "histo": HistogramIntersection, "l1b": L1BinRatioDistance, "chibrd": ChiSquareBRD } if metric in d: metric_param = d[metric]() else: metric_param = ChiSquareDistance() classifier = NearestNeighbor(dist_metric=metric_param, k=k) feature = ChainOperator(TanTriggsPreprocessing(), feature) # feature = ChainOperator(TanTriggsPreprocessing(0.1, 10.0, 1.0, 3.0), feature) self.model = PredictableModel(feature, classifier) # images in one list, id's on another id_list, face_list = zip(*input_faces) print "Train the model" start = time.clock() # model.compute(X, y) self.model.compute(face_list, id_list) stop = time.clock() print "Training done in", stop - start, " next...find a face" # threshold_lpq_normalized = threshold_function(0.67, 0.3) # threshold_lpq_chisquared = threshold_function(71.4, 70) # threshold_spatial_cosine = threshold_function(0.908, 0.908) # threshold_spatial_chisuearbrd = threshold_function() # threshold = threshold_lpq_normalized def find_face(self, input_face_image): assert self.model, "Model is not valid" res = self.model.predict(input_face_image) print res return self.threshold(res)
# Define a 1-NN classifier with Euclidean Distance: classifier = NearestNeighbor(dist_metric=EuclideanDistance(), k=1) # Define the model as the combination model = PredictableModel(feature=feature, classifier=classifier) # Compute the Fisherfaces on the given data (in X) and labels (in y): model.compute(X, y) # Then turn the first (at most) 16 eigenvectors into grayscale # images (note: eigenvectors are stored by column!) # E = [] # for i in xrange(min(model.feature.eigenvectors.shape[1], 16)): # e = model.feature.eigenvectors[:, i].reshape(X[0].shape) # E.append(minmax_normalize(e, 0, 255, dtype=np.uint8)) img_path = 'rawand1.jpg' coverted_img_path = "temp_%s" % img_path detect_face(img_path, outfile=coverted_img_path) img = Image.open(coverted_img_path) img = img.convert("L") p = model.predict(img)[0] label = keys[p] print label [X, y, keys] = read_images("../faces2/", keys=keys) model.classifier.update(X, y) p = model.predict(img)[0] label = keys[p] print label
rval, frame = vc.read() img = frame gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) faces = face_cascade.detectMultiScale(gray, 1.2, 3) for (x,y,w,h) in faces: cv2.rectangle(img,(x,y),(x+w,y+h),(255,0,0),2) sampleImage = gray[y:y+h, x:x+w] sampleImage = cv2.resize(sampleImage, (256,256)) #capiamo di chi è sta faccia [ predicted_label, generic_classifier_output] = model.predict(sampleImage) print [ predicted_label, generic_classifier_output] #scelta la soglia a 700. soglia maggiore di 700, accuratezza minore e v.v. if int(generic_classifier_output['distances']) <= 700: cv2.putText(img,'tu sei : '+str(subject_dictionary[predicted_label]), (x,y), cv2.FONT_HERSHEY_SIMPLEX,1,(0,0,250),3,1) cv2.imshow('result',img) if cv2.waitKey(10) == 27: break cv2.destroyAllWindows() vc.release()
# threshold_lpq_normalized = threshold_function(0.67, 0.3) threshold_lpq_chisquared = threshold_function(70, 35) # threshold_spatial_cosine = threshold_function(0.908, 0.908) # threshold_spatial_chisuearbrd = threshold_function() # threshold = threshold_lpq_normalized threshold = threshold_lpq_chisquared # threshold = threshold_spatial_cosine for image, id in test_list: target_full_name = os.path.join(test_path, image) prufu_mynd = utils.read_image(target_full_name) # prufu_mynd = fp.process_image(utils.read_image(target_full_name)) if prufu_mynd is not None: res = model.predict(prufu_mynd) found_id = threshold(res) # result_from_res(res) print found_id, ",", id else: print "Gat ekki opnað prufumynd" """ p1 = fp.process_image(utils.read_image("/Users/matti/Documents/forritun/att_faces/arora_01.jpg")) p2 = utils.read_image("/Users/matti/Dropbox/Skjöl/Meistaraverkefni/server/test_faces_to_search_for/arora_01.png") res1 = model.predict(p1) res2 = model.predict(p2) print res1 print res2 """ """
img = frame gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) faces = face_cascade.detectMultiScale(gray, 1.2, 3) for (x,y,w,h) in faces: cv2.rectangle(img,(x,y),(x+w,y+h),(255,0,0),2) sampleImage = gray[y:y+h, x:x+w] sampleImage = cv2.resize(sampleImage, (256,256)) #capiamo di chi è sta faccia [ predicted_label, generic_classifier_output] = model.predict(sampleImage) print [ predicted_label, generic_classifier_output] #scelta la soglia a 700. soglia maggiore di 700, accuratezza minore e v.v. if int(generic_classifier_output['distances']) <= 700: cv2.putText(img,'tu sei : '+str(subject_dictionary[predicted_label]), (x,y), cv2.FONT_HERSHEY_SIMPLEX,1,(0,0,250),3,1) cv2.imshow('result',img) if cv2.waitKey(10) == 27: break cv2.destroyAllWindows() vc.release()
mod3.compute(Xtrain,ytrain) mod4.compute(Xtrain,ytrain) mod5.compute(Xtrain,ytrain) mod6.compute(Xtrain,ytrain) mod7.compute(Xtrain,ytrain) mod8.compute(Xtrain,ytrain) mod9.compute(Xtrain,ytrain) mod10.compute(Xtrain,ytrain) #For Training Size 3 p=np.array(np.ones(len(Xtest))*9,dtype=int) count=0 for i in range(len(Xtest)): d10=mod10.predict(Xtest[i]) if (d10[1]['distances']<0.33): count+=1 p[i]=int(d10[0]) # print 'mod9',(d10[1]['distances']),p[i],ytest[i] continue d9=mod9.predict(Xtest[i]) if (d9[1]['distances']<40): count+=1 p[i]=int(d9[0]) # print 'mod9',abs(d9[1]['distances']),p[i],ytest[i] continue d6=mod6.predict(Xtest[i]) if (abs(d6[1]['distances'])>0.68): count+=1 p[i]=int(d6[0])
class FaceDatabase(object): def __init__(self, database_folder, feature_parameter="LPQ", metric="chi", k=3): self.model = None handler = logging.StreamHandler(sys.stdout) formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') handler.setFormatter(formatter) logger = logging.getLogger("facerec") logger.addHandler(handler) logger.setLevel(logging.DEBUG) path = database_folder start = time.clock() input_faces = utils.read_images_from_single_folder(path) stop = time.clock() print("read {}, images from {} in {} seconds.".format(len(input_faces), path, stop-start)) feature = None m = { "fisher": Fisherfaces, "fisher80": Fisherfaces, "pca": PCA, "pca10": PCA, "lda": LDA, "spatial": SpatialHistogram, "LPQ": SpatialHistogram } if feature_parameter in m: if feature_parameter == 'LPQ': feature = SpatialHistogram(LPQ()) self.threshold = threshold_function(71.4, 70) elif feature_parameter == 'fisher80': feature = Fisherfaces(80) self.threshold = threshold_function(0.61, 0.5) elif feature_parameter == 'fisher': feature = Fisherfaces() self.threshold = threshold_function(0.61, 0.5) elif feature_parameter == 'pca80': feature = PCA(80) else: feature = m[feature_parameter]() metric_param = None d = {"euclid": EuclideanDistance, "cosine": CosineDistance, "normal": NormalizedCorrelation, "chi": ChiSquareDistance, "histo": HistogramIntersection, "l1b": L1BinRatioDistance, "chibrd": ChiSquareBRD } if metric in d: metric_param = d[metric]() else: metric_param = ChiSquareDistance() classifier = NearestNeighbor(dist_metric=metric_param, k=k) feature = ChainOperator(TanTriggsPreprocessing(), feature) # feature = ChainOperator(TanTriggsPreprocessing(0.1, 10.0, 1.0, 3.0), feature) self.model = PredictableModel(feature, classifier) # images in one list, id's on another id_list, face_list = zip(*input_faces) print "Train the model" start = time.clock() # model.compute(X, y) self.model.compute(face_list, id_list) stop = time.clock() print "Training done in", stop-start, " next...find a face" # threshold_lpq_normalized = threshold_function(0.67, 0.3) # threshold_lpq_chisquared = threshold_function(71.4, 70) # threshold_spatial_cosine = threshold_function(0.908, 0.908) # threshold_spatial_chisuearbrd = threshold_function() # threshold = threshold_lpq_normalized def find_face(self, input_face_image): assert self.model, "Model is not valid" res = self.model.predict(input_face_image) print res return self.threshold(res)