def train1(): import os import cv2 import dlib import glob # 训练68个特征点 current_path = os.getcwd() faces_path = current_path + '/examples/faces' # 训练部分 # 参数设置 options = dlib.shape_predictor_training_options() options.oversampling_amount = 300 options.nu = 0.05 options.tree_depth = 2 options.be_verbose = True # 导入打好了标签的xml文件 training_xml_path = os.path.join(faces_path, "training_with_face_landmarks.xml") # 进行训练,训练好的模型将保存为predictor.dat dlib.train_shape_predictor(training_xml_path, "predictor.dat", options) # 打印在训练集中的准确率 print("\nTraining accuracy:{0}".format( dlib.test_shape_predictor(training_xml_path, "predictor.dat"))) # 导入测试集的xml文件 testing_xml_path = os.path.join(faces_path, "testing_with_face_landmarks.xml") # 打印在测试集中的准确率 print("\Testing accuracy:{0}".format( dlib.test_shape_predictor(testing_xml_path, "predictor.dat")))
def test_model(self, testfolder_path): """! Teste le modèle obtenu @param testfolder_path path+"test.xml" """ print("Testing error (average pixel deviation): {}".format( dlib.test_shape_predictor(testfolder_path, self.path_create_model + "predictor.dat")))
def test_shape_predictor_params(treeDepth, nu, cascadeDepth, featurePoolSize, numTestSplits, oversamplingAmount, oversamplingTransJitter, padding, lambdaParam): # Grab the default options for dlib's shape predictor and then set the values # based on the current hyperparameter values, casting to ints when appropriate options = dlib.shape_predictor_training_options() options.tree_depth = int(treeDepth) options.nu = nu options.cascade_depth = int(cascadeDepth) options.feature_pool_size = int(featurePoolSize) options.num_test_splits = int(numTestSplits) options.oversampling_amount = int(oversamplingAmount) options.oversampling_translation_jitter = oversamplingTransJitter options.feature_pool_region_padding = padding options.lambda_param = lambdaParam # Tell dlib to be verbose when training and utilize our supplied number of threads when training options.be_verbose = True options.num_threads = procs # Display the current set of options to our terminal print("[INFO] Starting training process...") print(options) sys.stdout.flush() # Train the model using the current set of hyperparameters dlib.train_shape_predictor(config.TRAIN_PATH, config.TEMP_MODEL_PATH, options) # Take the newly trained shape predictor model and evaluate it on both the training and testing set trainingError = dlib.test_shape_predictor(config.TRAIN_PATH, config.TEMP_MODEL_PATH) testingError = dlib.test_shape_predictor(config.TEST_PATH, config.TEMP_MODEL_PATH) # Display the training and testing errors for the current trial print("[INFO] train error: {}".format(trainingError)) print("[INFO] test error: {}".format(testingError)) sys.stdout.flush() # Return the error on the testing set return testingError
def train_model(self, trainfolder_path): """! Lance l'apprentissage du modèle avec les valeurs par défaut @param trainfolder : path+"train.xml" """ # self.parameter_model([500,6],0.6,1,18,700,40,500) dlib.train_shape_predictor(trainfolder_path, self.path_create_model + "predictor.dat", self.options) return "Training error (average pixel deviation): {}".format( dlib.test_shape_predictor( trainfolder_path, self.path_create_model + "predictor.dat"))
def test_params(cascade_depth, padding, nu, tree_depth, num_trees_per_cascade_level, lambda_param, jitter): options = dlib.shape_predictor_training_options() options.feature_pool_region_padding = padding options.cascade_depth = int(cascade_depth) options.nu = nu options.tree_depth = int(tree_depth) options.oversampling_translation_jitter = jitter options.num_trees_per_cascade_level = int(num_trees_per_cascade_level) options.lambda_param = lambda_param options.num_threads = 4 options.be_verbose = True print("start training") print(options) sys.stdout.flush() dlib.train_shape_predictor(training_xml_path, "bbr_predictor.dat", options) print("\nTraining error: ", dlib.test_shape_predictor(training_xml_path, "bbr_predictor.dat")) err = dlib.test_shape_predictor(testing_xml_path, "bbr_predictor.dat") print("\nTesting error: ", err) sys.stdout.flush() return err
# to a high amount (300) effectively boosts the training set size, so # that helps this example. # options.oversampling_amount = 300 # I'm also reducing the capacity of the model by explicitly increasing # the regularization (making nu smaller) and by using trees with # smaller depths. # options.nu = 0.05 # options.tree_depth = 2 options.be_verbose = True # dlib.train_shape_predictor() does the actual training. It will save the # final predictor to predictor.dat. The input is an XML file that lists the # images in the training dataset and also contains the positions of the face # parts. training_xml_path = os.path.join(image_folder, "4Dlib_training_images_with_landmarks.xml") dlib.train_shape_predictor(training_xml_path, output_folder + "/predictor.dat", options) # Now that we have a model we can test it. dlib.test_shape_predictor() # measures the average distance between a face landmark output by the # shape_predictor and where it should be according to the truth data. print("\nTraining error: {}".format( dlib.test_shape_predictor(training_xml_path, output_folder + "/predictor.dat"))) # The real test is to see how well it does on data it wasn't trained on. We # trained it on a very small dataset so the accuracy is not extremely high, but # it's still doing quite good. Moreover, if you train it on one of the large # face landmarking datasets you will obtain state-of-the-art results, as shown # in the Kazemi paper.
def measure_model_error(model, xml): '''requires: the model and xml path. It measures the error of the model on the given xml file of annotations.''' error = dlib.test_shape_predictor(xml, model) print("Error of the model: {} is {}".format(model, error))
options = dlib.shape_predictor_training_options() options.cascade_depth = 10 options.num_trees_per_cascade_level = 500 options.tree_depth = 4 options.nu = 0.1 options.oversampling_amount = 20 options.feature_pool_size = 400 options.feature_pool_region_padding = 0 options.lambda_param = 0.1 options.num_test_splits = 20 options.be_verbose = True trainingXMLPath = os.path.join(fldDataDir, "train_face_landmarks_70.xml") testingXMLPath = os.path.join(fldDataDir, "test_face_landmarks_70.xml") outputModelPath = os.path.join(fldDataDir, modelName) print("entering") if (os.path.exists(trainingXMLPath) and os.path.exists(testingXMLPath)): dlib.train_shape_predictor(trainingXMLPath, outputModelPath, options) print("\nTraining Accuracy: {}".format( dlib.test_shape_predictor(trainingXMLPath, outputModelPath))) print("\nTesting Accuracy: {}".format( dlib.test_shape_predictor(testingXMLPath, outputModelPath))) else: print('training and test XML files not found.') print('Please check paths:') print('train: {}'.format(trainingXmlPath)) print('test: {}'.format(testingXmlPath))
# -*- coding: utf-8 -*- from glob import glob import os import dlib import cv2 detector = dlib.simple_object_detector('../materials/recursos/clock_detector.svm') detector_points = dlib.shape_predictor('../materials/recursos/detector_clock_points.dat') print(dlib.test_shape_predictor('../materials/recursos/clock_points_test.xml', '../materials/recursos/detector_clock_points.dat')) def print_points(image, points): for p in points.parts(): cv2.circle(image, (p.x, p.y), 2, (255, 0, 0), 3) for file in glob(os.path.join('../materials/relogios_teste', '*.jpg')): image = cv2.imread(file) detected_objects = detector(image, 2) for _object in detected_objects: l, t, r, b = int(_object.left()), int(_object.top()), int(_object.right()), int(_object.bottom()) cv2.rectangle(image, (l, t), (r, b), (0, 0, 255), 2) points = detector_points(image, _object) print_points(image, points) cv2.imshow('Detector points', image) cv2.waitKey(0)
import dlib options = dlib.shape_predictor_training_options() options.feature_pool_region_padding = 0.1 options.cascade_depth = 10 options.landmark_relative_padding_mode = False options.nu = 0.05 options.tree_depth = 2 options.oversampling_translation_jitter = 0.1 options.oversampling_amount = 200 options.num_threads = 4 options.be_verbose = True dlib.train_shape_predictor("face_landmarking.xml", "landmark_predictor.dat", options) print( "\nTraining error: ", dlib.test_shape_predictor("face_landmarking.xml", "landmark_predictor.dat"))
# I'm also reducing the capacity of the model by explicitly increasing # the regularization (making nu smaller) and by using trees with # smaller depths. options.nu = 0.05 options.tree_depth = 5 #default 3 options.be_verbose = True options.num_threads = 4 #cpu core number # dlib.train_shape_predictor() does the actual training. It will save the # final predictor to predictor.dat. The input is an XML file that lists the # images in the training dataset and also contains the positions of the face # parts. training_xml_path = os.path.join(faces_folder, "labels_cfrs_train.xml") dlib.train_shape_predictor(training_xml_path, "cfrs_shape_predictor_face_landmarks.dat", options) # Now that we have a model we can test it. dlib.test_shape_predictor() # measures the average distance between a face landmark output by the # shape_predictor and where it should be according to the truth data. print("\nTraining accuracy: {}".format( dlib.test_shape_predictor(training_xml_path, "cfrs_shape_predictor_face_landmarks.dat"))) # The real test is to see how well it does on data it wasn't trained on. We # trained it on a very small dataset so the accuracy is not extremely high, but # it's still doing quite good. Moreover, if you train it on one of the large # face landmarking datasets you will obtain state-of-the-art results, as shown # in the Kazemi paper. testing_xml_path = os.path.join(faces_folder, "labels_cfrs_test.xml") print("Testing accuracy: {}".format( dlib.test_shape_predictor(testing_xml_path, "cfrs_shape_predictor_face_landmarks.dat")))
import os,sys,logging import glob import dlib from skimage import io #Setting up debug states logging.basicConfig(stream=sys.stderr, level=logging.DEBUG) # make sure there is a path to img folder in the argument if len(sys.argv) != 3: logging.error( "********** Please give a path to the face images direcotry then the landmark_predictor dat for the argument! **********") exit() # load the img foldfer to a variable img_folder = sys.argv[1] predictorPath = sys.argv[2] xml_name = raw_input("-----------xml file name (including .xml): ") testing_xml_path = os.path.join(img_folder, xml_name) print("\n Testing Accuracy: {}".format( dlib.test_shape_predictor(testing_xml_path, predictorPath))) dlib.hit_enter_to_continue()
# USAGE # python tune_predictor_hyperparams.py # import the necessary packages from pyimagesearch import config from sklearn.model_selection import ParameterGrid import multiprocessing import numpy as np import random import time import dlib import cv2 import os import cProfile import re dlib.test_shape_predictor(config.TEST_PATH, config.TEMP_MODEL_PATH)
def evaluate_model_acc(xmlPath, predPath): # compute and return the error (lower is better) of the shape # predictor over our testing path return dlib.test_shape_predictor(xmlPath, predPath)
# Now let's train the bounding box regression model using the dataset we just made. import dlib training_xml_file = "images/small_face_dataset/faces_600_bbr.xml" options = dlib.shape_predictor_training_options() options.num_threads = 4 options.be_verbose = True # I'll explain how I selected these magic numbers in a few minutes. options.cascade_depth = 7 options.tree_depth = 2 options.num_trees_per_cascade_level = 277 options.nu = 0.0326222 options.oversampling_amount = 20 options.oversampling_translation_jitter = 0.181914 options.feature_pool_size = 400 options.lambda_param = 0.14798 options.num_test_splits = 20 options.feature_pool_region_padding = 0.108275 dlib.train_shape_predictor(training_xml_file, "bbr_predictor.dat", options) print("\nTraining error: ", dlib.test_shape_predictor(training_xml_file, "bbr_predictor.dat"))
options.oversampling_amount = 5 # options.be_verbose = True # dlib.train_shape_predictor() does the actual training. It will save the # final predictor to predictor.dat. The input is an XML file that lists the # images in the training dataset and also contains the positions of the face # parts. training_xml_path = os.path.join(ear_data, "ear_train.xml") dlib.train_shape_predictor(training_xml_path, "ear_landmark_predictor.dat", options) # Now that we have a model we can test it. dlib.test_shape_predictor() # measures the average distance between a face landmark output by the # shape_predictor and where it should be according to the truth data. print("\nTraining accuracy: {}".format( dlib.test_shape_predictor(training_xml_path, "ear_landmark_predictor.dat"))) # The real test is to see how well it does on data it wasn't trained on. We # trained it on a very small dataset so the accuracy is not extremely high, but # it's still doing quite good. Moreover, if you train it on one of the large # face landmarking datasets you will obtain state-of-the-art results, as shown # in the Kazemi paper. testing_xml_path = os.path.join(ear_data, "ear_test.xml") print("Testing accuracy: {}".format( dlib.test_shape_predictor(testing_xml_path, "ear_landmark_predictor.dat"))) # Now let's use it as you would in a normal application. First we will load it # from disk. We also need to load a face detector to provide the initial # estimate of the facial location. # predictor = dlib.shape_predictor("ear_landmark_predictor.dat") # detector = dlib.get_frontal_face_detector() #
import os model_name = "shape_predictor_70_face_landmarks.dat" options = dlib.shape_predictor_training_options() options.cascade_depth = 10 options.num_trees_per_cascade_level = 500 options.tree_depth = 4 options.nu = 0.1 options.oversampling_amount = 20 options.feature_pool_size = 400 options.feature_pool_region_padding = 0 options.lambda_param = 0.1 options.num_test_splits = 20 # Tell the trainer to print status messages to the console so we can # see training options and how long the training will take. options.be_verbose = True training_xml_path = "/home/jash/Desktop/JashWork/Advanced-Computer-Vision/data/models/facial_landmark_data/70_points/training_with_face_landmarks.xml" testing_xml_path = "/home/jash/Desktop/JashWork/Advanced-Computer-Vision/data/models/facial_landmark_data/70_points/testing_with_face_landmarks.xml" output_model_path = "/home/jash/Desktop/JashWork/Advanced-Computer-Vision/data/models/" + model_name if os.path.exists(training_xml_path) and os.path.exists(testing_xml_path): dlib.train_shape_predictor(training_xml_path, output_model_path, options) print("Training error: {}".format( dlib.test_shape_predictor(training_xml_path, output_model_path))) print("Testing error: {}".format( dlib.test_shape_predictor(testing_xml_path, output_model_path)))
def prepareModel(self): a = ModelPoints() a.instantiate() self.text.configure(state='normal') self.text.insert("insert", "\n#########################################") self.text.insert("insert", "#########################################") self.text.insert( "insert", "\n\t\t\tModèle initialisé : " + str(date.today()) + " " + str(datetime.now().time())) self.text.insert("insert", "\n\n--> Nombre d'images : ") self.text.insert("insert", str(len(os.listdir(InterfacePoint.imagefolder_path)))) self.text.update() a.split() self.text.insert("insert", "\n\n--> Dossiers train / test crées : ") self.text.insert( "insert", str(len(os.listdir(InterfacePoint.modele_path + "train"))) + " images Train + ") self.text.insert( "insert", str(len(os.listdir(InterfacePoint.modele_path + "test"))) + " images Test") self.text.update() c = str(a.options()) self.text.insert("insert", "\n\n--> Options set :") for x in c[c.find("(") + 1:c.find(")")].split(','): self.text.insert("insert", "\t" + x + "\n") message = "\n\n--> Fitting trees..." self.text.insert("insert", message) message = "\n\n\t\t\tPLEASE WAIT UNTIL FINISHED !" self.text.insert("insert", message) self.text.update() start = time.time() a.train() end = time.time() self.text.insert( "insert", "\n\n--> Time elapsed : " + str(timedelta(seconds=round(end - start))) + " s") self.text.update() self.text.insert( "insert", "\n--> Apprentissage terminé\n--> Modèle mis à jour : ") self.text.update() self.text.insert( "insert", str( round( int( os.path.getsize(InterfacePoint.modele_path + "predictor.dat")) / 1048000)) + " Mo") self.text.insert( "insert", "\n--> Training error: {}".format( round( dlib.test_shape_predictor( InterfacePoint.trainfolder_path, InterfacePoint.modele_path + "predictor.dat"), 2))) self.text.insert("insert", " pixels") self.text.insert( "insert", "\n\t\t\tModèle finalisé : " + str(date.today()) + " " + str(datetime.now().time())) self.text.insert("insert", "\n#########################################") self.text.insert("insert", "#########################################") self.text.update() self.text.configure(state='disabled')
# smaller depths. options.nu = 0.05 options.tree_depth = 2 options.be_verbose = True # dlib.train_shape_predictor() does the actual training. It will save the # final predictor to predictor.dat. The input is an XML file that lists the # images in the training dataset and also contains the positions of the face # parts. training_xml_path = os.path.join(faces_folder, "training_with_face_landmarks.xml") dlib.train_shape_predictor(training_xml_path, "predictor.dat", options) # Now that we have a model we can test it. dlib.test_shape_predictor() # measures the average distance between a face landmark output by the # shape_predictor and where it should be according to the truth data. print("\nTraining accuracy: {}".format(dlib.test_shape_predictor(training_xml_path, "predictor.dat"))) # The real test is to see how well it does on data it wasn't trained on. We # trained it on a very small dataset so the accuracy is not extremely high, but # it's still doing quite good. Moreover, if you train it on one of the large # face landmarking datasets you will obtain state-of-the-art results, as shown # in the Kazemi paper. testing_xml_path = os.path.join(faces_folder, "testing_with_face_landmarks.xml") print("Testing accuracy: {}".format(dlib.test_shape_predictor(testing_xml_path, "predictor.dat"))) # Now let's use it as you would in a normal application. First we will load it # from disk. We also need to load a face detector to provide the initial # estimate of the facial location. predictor = dlib.shape_predictor("predictor.dat") detector = dlib.get_frontal_face_detector() # Now let's run the detector and shape_predictor over the images in the faces
ap.add_argument("-n", "--num-trees", type=int, default=500, help="number of regression trees (default = 500)", metavar='') args = vars(ap.parse_args()) #Setting up the training parameters options = dlib.shape_predictor_training_options() options.num_trees_per_cascade_level = args['num_trees'] options.nu = args['nu'] options.num_threads = args['threads'] options.tree_depth = args['tree_depth'] options.cascade_depth = args['cascade_depth'] options.feature_pool_size = args['feature_pool_size'] options.num_test_splits = args['test_splits'] options.oversampling_amount = args['oversampling'] options.be_verbose = True #Training the model train_path = os.path.join('./', args['dataset']) dlib.train_shape_predictor(train_path, args['out'] + ".dat", options) print("Training error (average pixel deviation): {}".format( dlib.test_shape_predictor(train_path, args['out'] + ".dat"))) #Testing the model (if test data was provided) if args['test'] is not None: test_path = os.path.join('./', args['test']) print("Testing error (average pixel deviation): {}".format( dlib.test_shape_predictor(test_path, args['out'] + ".dat")))
def evaluate_model_acc(xml_path, pred_path): # Compute and return the error (lower is better) of the shape predictor over the testing path return dlib.test_shape_predictor(xml_path, pred_path)
# images with boxes. To see how to use it read the tools/imglab/README.txt # file. But for this example, we just use the training.xml file included with # dlib. if not os.path.exists(os.path.join(ip_folder,"detector.dat")): os.chdir(os.path.dirname(training_xml_path)) dlib.train_shape_predictor("training.xml", os.path.join(ip_folder,"detector.dat"), options) # Now that we have a face detector we can test it. The first statement tests # it on the training data. It will print(the precision, recall, and then) # average precision. print("") # Print blank line to create gap from previous output os.chdir(os.path.dirname(training_xml_path)) train_test = dlib.test_shape_predictor("training.xml", os.path.join(ip_folder,"detector.dat").replace("\\","/")) print("Training accuracy: {}".format(train_test)) # However, to get an idea if it really worked without overfitting we need to # run it on images it wasn't trained on. The next line does this. Happily, we # see that the object detector works perfectly on the testing images. #print("Testing accuracy: {}".format(dlib.test_simple_object_detector(testing_xml_path, os.path.join(current_dir,"detector.dat"))) os.chdir(os.path.dirname(testing_xml_path)) true_test = dlib.test_shape_predictor("testing.xml", os.path.join(ip_folder,"detector.dat").replace("\\","/")) print("Testing accuracy: {}".format(true_test)) os.chdir(current_dir) # Now let's use the detector as you would in a normal application. First we # will load it from disk. predictor = dlib.shape_predictor(os.path.join(ip_folder,"detector.dat").replace("\\","/")) detector = dlib.simple_object_detector(os.path.join(ip_folder,"detector.svm").replace("\\","/"))
import dlib import cv2 import glob import os detectorClock = dlib.simple_object_detector("assets/detector_relogios.svm") clockPointsDetector = dlib.shape_predictor("assets/detector_relogios_pontos.dat") print(dlib.test_shape_predictor("assets/teste_relogios_pontos.xml", "assets/detector_relogios_pontos.dat")) def imprimirPoints(image, points): for p in points.parts(): cv2.circle(image, (p.x, p.y), 2, (0, 255, 0)) for arquive in glob.glob(os.path.join("relogios_teste", "*.jpg")): image = cv2.imread(arquive) objectDetected = detectorClock(image, 2) for clock in objectDetected: l, t, r, b = (int(clock.left()), int(clock.top()), int(clock.right()), int(clock.bottom())) points = clockPointsDetector(image, clock) imprimirPoints(image, points) cv2.rectangle(image, (l, t), (r, b), (0, 0, 255), 2) cv2.imshow("Points Detector :", image) cv2.waitKey(0) cv2.destroyAllWindows()
# USAGE # python evaluate_shape_predictor.py --predictor eye_predictor.dat --xml ibug_300W_large_face_landmark_dataset/labels_ibug_300W_train_eyes.xml # python evaluate_shape_predictor.py --predictor eye_predictor.dat --xml ibug_300W_large_face_landmark_dataset/labels_ibug_300W_test_eyes.xml # import the necessary packages import argparse import dlib # construct the argument parser and parse the arguments ''' ap = argparse.ArgumentParser() ap.add_argument("-p", "--predictor", required=True, help="path to trained dlib shape predictor model") ap.add_argument("-x", "--xml", required=True, help="path to input training/testing XML file") args = vars(ap.parse_args()) ''' xml_path = "../cartoon-20201209T065805Z-001/cartoon/Cartoon_face_with_landmarks_test.xml" model_path = "predictor_points.dat" # compute the error over the supplied data split and display it to # our screen print("[INFO] evaluating shape predictor...") error = dlib.test_shape_predictor(xml_path, model_path) print("[INFO] error: {}".format(error))
def measure_model_error(model, xml_annotations): """requires: the model and xml path. It measures the error of the model on the given xml file of annotations.""" error = dlib.test_shape_predictor(xml_annotations, model) print('Error of the model: ' + str(model) + ' is ' + str(error))
import multiprocessing import os import dlib options = dlib.shape_predictor_training_options() options.tree_depth = 3 options.nu = 0.3 options.cascade_depth = 30 options.feature_pool_size = 800 options.num_test_splits = 20 options.oversampling_amount = 1 options.oversampling_translation_jitter = 0.4 options.be_verbose = True options.num_threads = multiprocessing.cpu_count() train_xml_path = os.path.abspath("./youtube_faces_train.xml") predictor_dat = "./youtube_faces_68_points.dat" dlib.train_shape_predictor(train_xml_path, predictor_dat, options) print("\nTraining MAE: {}".format( dlib.test_shape_predictor(train_xml_path, predictor_dat))) test_xml_path = os.path.abspath("./youtube_faces_test.xml") print("Testing MAE: {}".format( dlib.test_shape_predictor(test_xml_path, predictor_dat)))
# USAGE # python evaluate_shape_predictor.py --predictor eye_predictor.dat --xml ibug_300W_large_face_landmark_dataset/labels_ibug_300W_train_eyes.xml # python evaluate_shape_predictor.py --predictor eye_predictor.dat --xml ibug_300W_large_face_landmark_dataset/labels_ibug_300W_test_eyes.xml # import the necessary packages import argparse import dlib # construct the argument parser and parse the arguments ap = argparse.ArgumentParser() ap.add_argument("-p", "--predictor", required=True, help="path to trained dlib shape predictor model") ap.add_argument("-x", "--xml", required=True, help="path to input training/testing XML file") args = vars(ap.parse_args()) # compute the error over the supplied data split and display it to # our screen print("[INFO] evaluating shape predictor...") error = dlib.test_shape_predictor(args["xml"], args["predictor"]) print("[INFO] error: {}".format(error))
def main(): # construct the argument parser and parse the arguments ap = argparse.ArgumentParser( formatter_class=argparse.ArgumentDefaultsHelpFormatter) ap.add_argument("-p", "--path", required=True, help="path to dataset") ap.add_argument("-v", "--verbose", default=True, help="be_verbose flag") ap.add_argument("-cd", "--cascade_depth", type=int, default=10, help="cascade_depth value") ap.add_argument("-td", "--tree_depth", type=int, default=4, help="tree_depth value") ap.add_argument("-ntpcl", "--num_tress_per_cascade_level", type=int, default=500, help="num_tress_per_cascade_level value") ap.add_argument("-nu", "--nu", default=0.1, type=float, help="nu value") ap.add_argument("-oa", "--oversampling_amount", type=int, default=20, help="oversampling_amount value") ap.add_argument("-fps", "--feature_pool_size", type=int, default=400, help="feature_pool_size value") ap.add_argument("-l", "--lambda_param", default=0.1, type=float, help="lambda_param value") ap.add_argument("-nts", "--num_test_splits", type=int, default=20, help="num_test_splits value") ap.add_argument("-fprp", "--feature_pool_region_padding", default=0, type=int, help="feature_pool_region_padding value") ap.add_argument("-rs", "--random_seed", default="", help="random_seed value") ap.add_argument("-nt", "--num_threads", default=0, type=int, help="num_threads value") ap.add_argument("-m", "--model_name", required=True, help="model_name") args = ap.parse_args() # In this example we are going to train a face detector based on the small # faces dataset in the examples/faces directory. This means you need to supply # the path to this faces folder as a command line argument so we will know # where it is. faces_folder = args.path options = dlib.shape_predictor_training_options() # Now make the object responsible for training the model. # This algorithm has a bunch of parameters you can mess with. The # documentation for the shape_predictor_trainer explains all of them. # You should also read Kazemi's paper which explains all the parameters # in great detail. However, here I'm just setting three of them # differently than their default values. I'm doing this because we # have a very small dataset. In particular, setting the oversampling # to a high amount (300) effectively boosts the training set size, so # that helps this example. # options.oversampling_amount = args.oversampling_amount # I'm also reducing the capacity of the model by explicitly increasing # the regularization (making nu smaller) and by using trees with # smaller depths. # options.nu = 0.05 # options.lambda_param = 0.1 # options.tree_depth = 5 # options.be_verbose = True # options.num_threads = 0 # model_name = "predictor_1.dat" options.be_verbose = args.verbose options.cascade_depth = args.cascade_depth options.tree_depth = args.tree_depth options.num_tress_per_cascade_level = args.num_tress_per_cascade_level options.nu = args.nu options.oversampling_amount = args.oversampling_amount options.feature_pool_size = args.feature_pool_size options.lambda_param = args.lambda_param options.num_test_splits = args.num_test_splits options.feature_pool_region_padding = args.feature_pool_region_padding options.random_seed = args.random_seed options.num_threads = args.num_threads model_name = args.model_name # dlib.train_shape_predictor() does the actual training. It will save the # final predictor to predictor.dat. The input is an XML file that lists the # images in the training dataset and also contains the positions of the face # parts. training_xml_path = os.path.join(faces_folder, "labels_ibug_300W_train.xml") dlib.train_shape_predictor(training_xml_path, model_name, options) # Now that we have a model we can test it. dlib.test_shape_predictor() # measures the average distance between a face landmark output by the # shape_predictor and where it should be according to the truth data. print("\nTraining accuracy: {}".format( dlib.test_shape_predictor(training_xml_path, model_name))) # The real test is to see how well it does on data it wasn't trained on. We # trained it on a very small dataset so the accuracy is not extremely high, but # it's still doing quite good. Moreover, if you train it on one of the large # face landmarking datasets you will obtain state-of-the-art results, as shown # in the Kazemi paper. testing_xml_path = os.path.join(faces_folder, "labels_ibug_300W.xml") print("Testing accuracy: {}".format( dlib.test_shape_predictor(testing_xml_path, model_name))) # Now let's use it as you would in a normal application. First we will load it # from disk. We also need to load a face detector to provide the initial # estimate of the facial location. predictor = dlib.shape_predictor(model_name) detector = dlib.get_frontal_face_detector() # Now let's run the detector and shape_predictor over the images in the faces # folder and display the results. print( "Showing detections and predictions on the images in the faces folder..." ) win = dlib.image_window() for f in glob.glob(os.path.join(faces_folder, "*.jpg")): print("Processing file: {}".format(f)) img = io.imread(f) win.clear_overlay() win.set_image(img) # Ask the detector to find the bounding boxes of each face. The 1 in the # second argument indicates that we should upsample the image 1 time. This # will make everything bigger and allow us to detect more faces. dets = detector(img, 1) print("Number of faces detected: {}".format(len(dets))) for k, d in enumerate(dets): print("Detection {}: Left: {} Top: {} Right: {} Bottom: {}".format( k, d.left(), d.top(), d.right(), d.bottom())) # Get the landmarks/parts for the face in box d. shape = predictor(img, d) print("Part 0: {}, Part 1: {} ...".format(shape.part(0), shape.part(1))) # Draw the face landmarks on the screen. win.add_overlay(shape) win.add_overlay(dets) dlib.hit_enter_to_continue()
#!/usr/bin/env python # -*- coding: utf-8 -*- # @Time : 2018/10/1 10:49 # @Author : 周文帆小组 # @Site : # @File : face_re.py # @Software: PyCharm import dlib, os current_path = os.getcwd() faces_path = current_path + '/faces/' options = dlib.shape_predictor_training_options() options.oversampling_amount = 300 options.nu = 0.05 options.tree_depth = 2 options.be_verbose = True train_path = os.path.join(faces_path, 'training_with_face_landmarks.xml') #利用标记好了的xml文件进行人脸特征检测器训练,xml文件在faces文件夹内 dlib.train_shape_predictor(train_path, 'predictor.dat', options) #打印检测器的识别精度 print('\nTraining accuracy:{}'.format( dlib.test_shape_predictor(train_path, 'predictor.dat')))
options.nu = 0.05 options.tree_depth = 2 options.be_verbose = True # dlib.train_shape_predictor() does the actual training. It will save the # final predictor to predictor.dat. The input is an XML file that lists the # images in the training dataset and also contains the positions of the face # parts. training_xml_path = os.path.join(faces_folder, "training_with_face_landmarks.xml") dlib.train_shape_predictor(training_xml_path, "predictor.dat", options) # Now that we have a model we can test it. dlib.test_shape_predictor() # measures the average distance between a face landmark output by the # shape_predictor and where it should be according to the truth data. print("\nTraining accuracy: {}".format( dlib.test_shape_predictor(training_xml_path, "predictor.dat"))) # The real test is to see how well it does on data it wasn't trained on. We # trained it on a very small dataset so the accuracy is not extremely high, but # it's still doing quite good. Moreover, if you train it on one of the large # face landmarking datasets you will obtain state-of-the-art results, as shown # in the Kazemi paper. testing_xml_path = os.path.join(faces_folder, "testing_with_face_landmarks.xml") print("Testing accuracy: {}".format( dlib.test_shape_predictor(testing_xml_path, "predictor.dat"))) # Now let's use it as you would in a normal application. First we will load it # from disk. We also need to load a face detector to provide the initial # estimate of the facial location. predictor = dlib.shape_predictor("predictor.dat") detector = dlib.get_frontal_face_detector()
options.nu = 0.05 options.tree_depth = 2 options.be_verbose = True # dlib.train_shape_predictor() does the actual training. It will save the # final predictor to predictor.dat. The input is an XML file that lists the # images in the training dataset and also contains the positions of the face # parts. training_xml_path = os.path.join(faces_folder, "training_with_face_landmarks.xml") dlib.train_shape_predictor(training_xml_path, "predictor.dat", options) # Now that we have a model we can test it. dlib.test_shape_predictor() # measures the average distance between a face landmark output by the # shape_predictor and where it should be according to the truth data. print("\nTraining accuracy: {}".format( dlib.test_shape_predictor(training_xml_path, "predictor.dat"))) # The real test is to see how well it does on data it wasn't trained on. We # trained it on a very small dataset so the accuracy is not extremely high, but # it's still doing quite good. Moreover, if you train it on one of the large # face landmarking datasets you will obtain state-of-the-art results, as shown # in the Kazemi paper. testing_xml_path = os.path.join(faces_folder, "testing_with_face_landmarks.xml") print("Testing accuracy: {}".format( dlib.test_shape_predictor(testing_xml_path, "predictor.dat"))) # Now let's use it as you would in a normal application. First we will load it # from disk. We also need to load a face detector to provide the initial # estimate of the facial location. predictor = dlib.shape_predictor("predictor.dat") detector = dlib.get_frontal_face_detector()
training_options.feature_pool_region_padding = 0 #training_options.num_threads = 2 #setting the be_verbose setting to true so the training data will be printed out training_options.be_verbose = True # the training will take in an xml file with the imgs used for the training dataset # so we need to create that xml with the imgs in the given folder xml_name = raw_input("-----------xml file name (including .xml): ") training_xml_path = os.path.join(img_folder, xml_name) logging.debug("-Set the img xml") # now we create the predictor with the settings and imgs model_name = raw_input("-----------model name (including .dat): ") dlib.train_shape_predictor(training_xml_path, model_name, training_options) logging.debug("-Trained the new predictor") print("\n Training Accuracy: {}".format( dlib.test_shape_predictor(training_xml_path, model_name))) #now we wanna test the trained model with faces diffrent than the ones we used in training #testing_xml_path = os.path.join(img_folder, "testing.xml") #logging.debug("-Tested the new predictor") #print("\n Testing Accuracy: {}".format( dlib.test_shape_predictor(testing_xml_path, "trained_landmark_predictor.dat"))) dlib.hit_enter_to_continue()