diff options
Diffstat (limited to 'ml/dlib/python_examples')
19 files changed, 0 insertions, 2041 deletions
diff --git a/ml/dlib/python_examples/LICENSE_FOR_EXAMPLE_PROGRAMS.txt b/ml/dlib/python_examples/LICENSE_FOR_EXAMPLE_PROGRAMS.txt deleted file mode 100644 index 2bdbd5694..000000000 --- a/ml/dlib/python_examples/LICENSE_FOR_EXAMPLE_PROGRAMS.txt +++ /dev/null @@ -1,20 +0,0 @@ -The intent of the example programs supplied with the dlib C++ library is -to both instruct users and to also provide a simple body of code they -may copy and paste from. To make this as painless as possible all the -example programs have been placed into the public domain. - - -This work is hereby released into the Public Domain. -To view a copy of the public domain dedication, visit -http://creativecommons.org/licenses/publicdomain/ or send a -letter to - Creative Commons - 171 Second Street - Suite 300, - San Francisco, California, 94105, USA. - - -Public domain dedications are not recognized by some countries. So -if you live in an area where the above dedication isn't valid then -you can consider the example programs to be licensed under the Boost -Software License. diff --git a/ml/dlib/python_examples/cnn_face_detector.py b/ml/dlib/python_examples/cnn_face_detector.py deleted file mode 100755 index 75357a62f..000000000 --- a/ml/dlib/python_examples/cnn_face_detector.py +++ /dev/null @@ -1,85 +0,0 @@ -#!/usr/bin/python -# The contents of this file are in the public domain. See LICENSE_FOR_EXAMPLE_PROGRAMS.txt -# -# This example shows how to run a CNN based face detector using dlib. The -# example loads a pretrained model and uses it to find faces in images. The -# CNN model is much more accurate than the HOG based model shown in the -# face_detector.py example, but takes much more computational power to -# run, and is meant to be executed on a GPU to attain reasonable speed. -# -# You can download the pre-trained model from: -# http://dlib.net/files/mmod_human_face_detector.dat.bz2 -# -# The examples/faces folder contains some jpg images of people. You can run -# this program on them and see the detections by executing the -# following command: -# ./cnn_face_detector.py mmod_human_face_detector.dat ../examples/faces/*.jpg -# -# -# COMPILING/INSTALLING THE DLIB PYTHON INTERFACE -# You can install dlib using the command: -# pip install dlib -# -# Alternatively, if you want to compile dlib yourself then go into the dlib -# root folder and run: -# python setup.py install -# or -# python setup.py install --yes USE_AVX_INSTRUCTIONS --yes DLIB_USE_CUDA -# if you have a CPU that supports AVX instructions, you have an Nvidia GPU -# and you have CUDA installed since this makes things run *much* faster. -# -# Compiling dlib should work on any operating system so long as you have -# CMake installed. On Ubuntu, this can be done easily by running the -# command: -# sudo apt-get install cmake -# -# Also note that this example requires scikit-image which can be installed -# via the command: -# pip install scikit-image -# Or downloaded from http://scikit-image.org/download.html. - -import sys -import dlib -from skimage import io - -if len(sys.argv) < 3: - print( - "Call this program like this:\n" - " ./cnn_face_detector.py mmod_human_face_detector.dat ../examples/faces/*.jpg\n" - "You can get the mmod_human_face_detector.dat file from:\n" - " http://dlib.net/files/mmod_human_face_detector.dat.bz2") - exit() - -cnn_face_detector = dlib.cnn_face_detection_model_v1(sys.argv[1]) -win = dlib.image_window() - -for f in sys.argv[2:]: - print("Processing file: {}".format(f)) - img = io.imread(f) - # 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 = cnn_face_detector(img, 1) - ''' - This detector returns a mmod_rectangles object. This object contains a list of mmod_rectangle objects. - These objects can be accessed by simply iterating over the mmod_rectangles object - The mmod_rectangle object has two member variables, a dlib.rectangle object, and a confidence score. - - It is also possible to pass a list of images to the detector. - - like this: dets = cnn_face_detector([image list], upsample_num, batch_size = 128) - - In this case it will return a mmod_rectangless object. - This object behaves just like a list of lists and can be iterated over. - ''' - print("Number of faces detected: {}".format(len(dets))) - for i, d in enumerate(dets): - print("Detection {}: Left: {} Top: {} Right: {} Bottom: {} Confidence: {}".format( - i, d.rect.left(), d.rect.top(), d.rect.right(), d.rect.bottom(), d.confidence)) - - rects = dlib.rectangles() - rects.extend([d.rect for d in dets]) - - win.clear_overlay() - win.set_image(img) - win.add_overlay(rects) - dlib.hit_enter_to_continue() diff --git a/ml/dlib/python_examples/correlation_tracker.py b/ml/dlib/python_examples/correlation_tracker.py deleted file mode 100755 index 4493a55b7..000000000 --- a/ml/dlib/python_examples/correlation_tracker.py +++ /dev/null @@ -1,72 +0,0 @@ -#!/usr/bin/python -# The contents of this file are in the public domain. See LICENSE_FOR_EXAMPLE_PROGRAMS.txt -# -# This example shows how to use the correlation_tracker from the dlib Python -# library. This object lets you track the position of an object as it moves -# from frame to frame in a video sequence. To use it, you give the -# correlation_tracker the bounding box of the object you want to track in the -# current video frame. Then it will identify the location of the object in -# subsequent frames. -# -# In this particular example, we are going to run on the -# video sequence that comes with dlib, which can be found in the -# examples/video_frames folder. This video shows a juice box sitting on a table -# and someone is waving the camera around. The task is to track the position of -# the juice box as the camera moves around. -# -# -# COMPILING/INSTALLING THE DLIB PYTHON INTERFACE -# You can install dlib using the command: -# pip install dlib -# -# Alternatively, if you want to compile dlib yourself then go into the dlib -# root folder and run: -# python setup.py install -# or -# python setup.py install --yes USE_AVX_INSTRUCTIONS -# if you have a CPU that supports AVX instructions, since this makes some -# things run faster. -# -# Compiling dlib should work on any operating system so long as you have -# CMake installed. On Ubuntu, this can be done easily by running the -# command: -# sudo apt-get install cmake -# -# Also note that this example requires scikit-image which can be installed -# via the command: -# pip install scikit-image -# Or downloaded from http://scikit-image.org/download.html. - -import os -import glob - -import dlib -from skimage import io - -# Path to the video frames -video_folder = os.path.join("..", "examples", "video_frames") - -# Create the correlation tracker - the object needs to be initialized -# before it can be used -tracker = dlib.correlation_tracker() - -win = dlib.image_window() -# We will track the frames as we load them off of disk -for k, f in enumerate(sorted(glob.glob(os.path.join(video_folder, "*.jpg")))): - print("Processing Frame {}".format(k)) - img = io.imread(f) - - # We need to initialize the tracker on the first frame - if k == 0: - # Start a track on the juice box. If you look at the first frame you - # will see that the juice box is contained within the bounding - # box (74, 67, 112, 153). - tracker.start_track(img, dlib.rectangle(74, 67, 112, 153)) - else: - # Else we just attempt to track from the previous frame - tracker.update(img) - - win.clear_overlay() - win.set_image(img) - win.add_overlay(tracker.get_position()) - dlib.hit_enter_to_continue() diff --git a/ml/dlib/python_examples/face_alignment.py b/ml/dlib/python_examples/face_alignment.py deleted file mode 100755 index 53df7a3e1..000000000 --- a/ml/dlib/python_examples/face_alignment.py +++ /dev/null @@ -1,91 +0,0 @@ -#!/usr/bin/python -# The contents of this file are in the public domain. See LICENSE_FOR_EXAMPLE_PROGRAMS.txt -# -# This example shows how to use dlib's face recognition tool for image alignment. -# -# COMPILING/INSTALLING THE DLIB PYTHON INTERFACE -# You can install dlib using the command: -# pip install dlib -# -# Alternatively, if you want to compile dlib yourself then go into the dlib -# root folder and run: -# python setup.py install -# or -# python setup.py install --yes USE_AVX_INSTRUCTIONS -# if you have a CPU that supports AVX instructions, since this makes some -# things run faster. This code will also use CUDA if you have CUDA and cuDNN -# installed. -# -# Compiling dlib should work on any operating system so long as you have -# CMake installed. On Ubuntu, this can be done easily by running the -# command: -# sudo apt-get install cmake -# -# Also note that this example requires OpenCV and Numpy which can be installed -# via the command: -# pip install opencv-python numpy -# Or downloaded from http://opencv.org/releases.html - -import sys - -import dlib -import cv2 -import numpy as np - -if len(sys.argv) != 3: - print( - "Call this program like this:\n" - " ./face_alignment.py shape_predictor_5_face_landmarks.dat ../examples/faces/bald_guys.jpg\n" - "You can download a trained facial shape predictor from:\n" - " http://dlib.net/files/shape_predictor_5_face_landmarks.dat.bz2\n") - exit() - -predictor_path = sys.argv[1] -face_file_path = sys.argv[2] - -# Load all the models we need: a detector to find the faces, a shape predictor -# to find face landmarks so we can precisely localize the face -detector = dlib.get_frontal_face_detector() -sp = dlib.shape_predictor(predictor_path) - -# Load the image using OpenCV -bgr_img = cv2.imread(face_file_path) -if bgr_img is None: - print("Sorry, we could not load '{}' as an image".format(face_file_path)) - exit() - -# Convert to RGB since dlib uses RGB images -img = cv2.cvtColor(bgr_img, cv2.COLOR_BGR2RGB) - -# 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) - -num_faces = len(dets) -if num_faces == 0: - print("Sorry, there were no faces found in '{}'".format(face_file_path)) - exit() - -# Find the 5 face landmarks we need to do the alignment. -faces = dlib.full_object_detections() -for detection in dets: - faces.append(sp(img, detection)) - -# Get the aligned face images -# Optionally: -# images = dlib.get_face_chips(img, faces, size=160, padding=0.25) -images = dlib.get_face_chips(img, faces, size=320) -for image in images: - cv_bgr_img = cv2.cvtColor(image, cv2.COLOR_RGB2BGR) - cv2.imshow('image',cv_bgr_img) - cv2.waitKey(0) - -# It is also possible to get a single chip -image = dlib.get_face_chip(img, faces[0]) -cv_bgr_img = cv2.cvtColor(image, cv2.COLOR_RGB2BGR) -cv2.imshow('image',cv_bgr_img) -cv2.waitKey(0) - -cv2.destroyAllWindows() - diff --git a/ml/dlib/python_examples/face_clustering.py b/ml/dlib/python_examples/face_clustering.py deleted file mode 100755 index 362613871..000000000 --- a/ml/dlib/python_examples/face_clustering.py +++ /dev/null @@ -1,127 +0,0 @@ -#!/usr/bin/python -# The contents of this file are in the public domain. See LICENSE_FOR_EXAMPLE_PROGRAMS.txt -# -# This example shows how to use dlib's face recognition tool for clustering using chinese_whispers. -# This is useful when you have a collection of photographs which you know are linked to -# a particular person, but the person may be photographed with multiple other people. -# In this example, we assume the largest cluster will contain photos of the common person in the -# collection of photographs. Then, we save extracted images of the face in the largest cluster in -# a 150x150 px format which is suitable for jittering and loading to perform metric learning (as shown -# in the dnn_metric_learning_on_images_ex.cpp example. -# https://github.com/davisking/dlib/blob/master/examples/dnn_metric_learning_on_images_ex.cpp -# -# COMPILING/INSTALLING THE DLIB PYTHON INTERFACE -# You can install dlib using the command: -# pip install dlib -# -# Alternatively, if you want to compile dlib yourself then go into the dlib -# root folder and run: -# python setup.py install -# or -# python setup.py install --yes USE_AVX_INSTRUCTIONS -# if you have a CPU that supports AVX instructions, since this makes some -# things run faster. This code will also use CUDA if you have CUDA and cuDNN -# installed. -# -# Compiling dlib should work on any operating system so long as you have -# CMake installed. On Ubuntu, this can be done easily by running the -# command: -# sudo apt-get install cmake -# -# Also note that this example requires scikit-image which can be installed -# via the command: -# pip install scikit-image -# Or downloaded from http://scikit-image.org/download.html. - -import sys -import os -import dlib -import glob -from skimage import io - -if len(sys.argv) != 5: - print( - "Call this program like this:\n" - " ./face_clustering.py shape_predictor_5_face_landmarks.dat dlib_face_recognition_resnet_model_v1.dat ../examples/faces output_folder\n" - "You can download a trained facial shape predictor and recognition model from:\n" - " http://dlib.net/files/shape_predictor_5_face_landmarks.dat.bz2\n" - " http://dlib.net/files/dlib_face_recognition_resnet_model_v1.dat.bz2") - exit() - -predictor_path = sys.argv[1] -face_rec_model_path = sys.argv[2] -faces_folder_path = sys.argv[3] -output_folder_path = sys.argv[4] - -# Load all the models we need: a detector to find the faces, a shape predictor -# to find face landmarks so we can precisely localize the face, and finally the -# face recognition model. -detector = dlib.get_frontal_face_detector() -sp = dlib.shape_predictor(predictor_path) -facerec = dlib.face_recognition_model_v1(face_rec_model_path) - -descriptors = [] -images = [] - -# Now find all the faces and compute 128D face descriptors for each face. -for f in glob.glob(os.path.join(faces_folder_path, "*.jpg")): - print("Processing file: {}".format(f)) - img = io.imread(f) - - # 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))) - - # Now process each face we found. - for k, d in enumerate(dets): - # Get the landmarks/parts for the face in box d. - shape = sp(img, d) - - # Compute the 128D vector that describes the face in img identified by - # shape. - face_descriptor = facerec.compute_face_descriptor(img, shape) - descriptors.append(face_descriptor) - images.append((img, shape)) - -# Now let's cluster the faces. -labels = dlib.chinese_whispers_clustering(descriptors, 0.5) -num_classes = len(set(labels)) -print("Number of clusters: {}".format(num_classes)) - -# Find biggest class -biggest_class = None -biggest_class_length = 0 -for i in range(0, num_classes): - class_length = len([label for label in labels if label == i]) - if class_length > biggest_class_length: - biggest_class_length = class_length - biggest_class = i - -print("Biggest cluster id number: {}".format(biggest_class)) -print("Number of faces in biggest cluster: {}".format(biggest_class_length)) - -# Find the indices for the biggest class -indices = [] -for i, label in enumerate(labels): - if label == biggest_class: - indices.append(i) - -print("Indices of images in the biggest cluster: {}".format(str(indices))) - -# Ensure output directory exists -if not os.path.isdir(output_folder_path): - os.makedirs(output_folder_path) - -# Save the extracted faces -print("Saving faces in largest cluster to output folder...") -for i, index in enumerate(indices): - img, shape = images[index] - file_path = os.path.join(output_folder_path, "face_" + str(i)) - # The size and padding arguments are optional with default size=150x150 and padding=0.25 - dlib.save_face_chip(img, shape, file_path, size=150, padding=0.25) - - - - diff --git a/ml/dlib/python_examples/face_detector.py b/ml/dlib/python_examples/face_detector.py deleted file mode 100755 index eed3732b0..000000000 --- a/ml/dlib/python_examples/face_detector.py +++ /dev/null @@ -1,84 +0,0 @@ -#!/usr/bin/python -# The contents of this file are in the public domain. See LICENSE_FOR_EXAMPLE_PROGRAMS.txt -# -# This example program shows how to find frontal human faces in an image. In -# particular, it shows how you can take a list of images from the command -# line and display each on the screen with red boxes overlaid on each human -# face. -# -# The examples/faces folder contains some jpg images of people. You can run -# this program on them and see the detections by executing the -# following command: -# ./face_detector.py ../examples/faces/*.jpg -# -# This face detector is made using the now classic Histogram of Oriented -# Gradients (HOG) feature combined with a linear classifier, an image -# pyramid, and sliding window detection scheme. This type of object detector -# is fairly general and capable of detecting many types of semi-rigid objects -# in addition to human faces. Therefore, if you are interested in making -# your own object detectors then read the train_object_detector.py example -# program. -# -# -# COMPILING/INSTALLING THE DLIB PYTHON INTERFACE -# You can install dlib using the command: -# pip install dlib -# -# Alternatively, if you want to compile dlib yourself then go into the dlib -# root folder and run: -# python setup.py install -# or -# python setup.py install --yes USE_AVX_INSTRUCTIONS -# if you have a CPU that supports AVX instructions, since this makes some -# things run faster. -# -# Compiling dlib should work on any operating system so long as you have -# CMake installed. On Ubuntu, this can be done easily by running the -# command: -# sudo apt-get install cmake -# -# Also note that this example requires scikit-image which can be installed -# via the command: -# pip install scikit-image -# Or downloaded from http://scikit-image.org/download.html. - -import sys - -import dlib -from skimage import io - - -detector = dlib.get_frontal_face_detector() -win = dlib.image_window() - -for f in sys.argv[1:]: - print("Processing file: {}".format(f)) - img = io.imread(f) - # 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 i, d in enumerate(dets): - print("Detection {}: Left: {} Top: {} Right: {} Bottom: {}".format( - i, d.left(), d.top(), d.right(), d.bottom())) - - win.clear_overlay() - win.set_image(img) - win.add_overlay(dets) - dlib.hit_enter_to_continue() - - -# Finally, if you really want to you can ask the detector to tell you the score -# for each detection. The score is bigger for more confident detections. -# The third argument to run is an optional adjustment to the detection threshold, -# where a negative value will return more detections and a positive value fewer. -# Also, the idx tells you which of the face sub-detectors matched. This can be -# used to broadly identify faces in different orientations. -if (len(sys.argv[1:]) > 0): - img = io.imread(sys.argv[1]) - dets, scores, idx = detector.run(img, 1, -1) - for i, d in enumerate(dets): - print("Detection {}, score: {}, face_type:{}".format( - d, scores[i], idx[i])) - diff --git a/ml/dlib/python_examples/face_jitter.py b/ml/dlib/python_examples/face_jitter.py deleted file mode 100755 index ee959846d..000000000 --- a/ml/dlib/python_examples/face_jitter.py +++ /dev/null @@ -1,97 +0,0 @@ -#!/usr/bin/python -# The contents of this file are in the public domain. See LICENSE_FOR_EXAMPLE_PROGRAMS.txt -# -# This example shows how faces were jittered and augmented to create training -# data for dlib's face recognition model. It takes an input image and -# disturbs the colors as well as applies random translations, rotations, and -# scaling. - -# -# COMPILING/INSTALLING THE DLIB PYTHON INTERFACE -# You can install dlib using the command: -# pip install dlib -# -# Alternatively, if you want to compile dlib yourself then go into the dlib -# root folder and run: -# python setup.py install -# or -# python setup.py install --yes USE_AVX_INSTRUCTIONS -# if you have a CPU that supports AVX instructions, since this makes some -# things run faster. This code will also use CUDA if you have CUDA and cuDNN -# installed. -# -# Compiling dlib should work on any operating system so long as you have -# CMake installed. On Ubuntu, this can be done easily by running the -# command: -# sudo apt-get install cmake -# -# Also note that this example requires OpenCV and Numpy which can be installed -# via the command: -# pip install opencv-python numpy -# -# The image file used in this example is in the public domain: -# https://commons.wikimedia.org/wiki/File:Tom_Cruise_avp_2014_4.jpg -import sys - -import dlib -import cv2 -import numpy as np - -def show_jittered_images(jittered_images): - ''' - Shows the specified jittered images one by one - ''' - for img in jittered_images: - cv_bgr_img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR) - cv2.imshow('image',cv_bgr_img) - cv2.waitKey(0) - -if len(sys.argv) != 2: - print( - "Call this program like this:\n" - " ./face_jitter.py shape_predictor_5_face_landmarks.dat\n" - "You can download a trained facial shape predictor from:\n" - " http://dlib.net/files/shape_predictor_5_face_landmarks.dat.bz2\n") - exit() - -predictor_path = sys.argv[1] -face_file_path = "../examples/faces/Tom_Cruise_avp_2014_4.jpg" - -# Load all the models we need: a detector to find the faces, a shape predictor -# to find face landmarks so we can precisely localize the face -detector = dlib.get_frontal_face_detector() -sp = dlib.shape_predictor(predictor_path) - -# Load the image using OpenCV -bgr_img = cv2.imread(face_file_path) -if bgr_img is None: - print("Sorry, we could not load '{}' as an image".format(face_file_path)) - exit() - -# Convert to RGB since dlib uses RGB images -img = cv2.cvtColor(bgr_img, cv2.COLOR_BGR2RGB) - -# Ask the detector to find the bounding boxes of each face. -dets = detector(img) - -num_faces = len(dets) - -# Find the 5 face landmarks we need to do the alignment. -faces = dlib.full_object_detections() -for detection in dets: - faces.append(sp(img, detection)) - -# Get the aligned face image and show it -image = dlib.get_face_chip(img, faces[0], size=320) -cv_bgr_img = cv2.cvtColor(image, cv2.COLOR_RGB2BGR) -cv2.imshow('image',cv_bgr_img) -cv2.waitKey(0) - -# Show 5 jittered images without data augmentation -jittered_images = dlib.jitter_image(image, num_jitters=5) -show_jittered_images(jittered_images) - -# Show 5 jittered images with data augmentation -jittered_images = dlib.jitter_image(image, num_jitters=5, disturb_colors=True) -show_jittered_images(jittered_images) -cv2.destroyAllWindows() diff --git a/ml/dlib/python_examples/face_landmark_detection.py b/ml/dlib/python_examples/face_landmark_detection.py deleted file mode 100755 index 351941317..000000000 --- a/ml/dlib/python_examples/face_landmark_detection.py +++ /dev/null @@ -1,100 +0,0 @@ -#!/usr/bin/python -# The contents of this file are in the public domain. See LICENSE_FOR_EXAMPLE_PROGRAMS.txt -# -# This example program shows how to find frontal human faces in an image and -# estimate their pose. The pose takes the form of 68 landmarks. These are -# points on the face such as the corners of the mouth, along the eyebrows, on -# the eyes, and so forth. -# -# The face detector we use is made using the classic Histogram of Oriented -# Gradients (HOG) feature combined with a linear classifier, an image pyramid, -# and sliding window detection scheme. The pose estimator was created by -# using dlib's implementation of the paper: -# One Millisecond Face Alignment with an Ensemble of Regression Trees by -# Vahid Kazemi and Josephine Sullivan, CVPR 2014 -# and was trained on the iBUG 300-W face landmark dataset (see -# https://ibug.doc.ic.ac.uk/resources/facial-point-annotations/): -# C. Sagonas, E. Antonakos, G, Tzimiropoulos, S. Zafeiriou, M. Pantic. -# 300 faces In-the-wild challenge: Database and results. -# Image and Vision Computing (IMAVIS), Special Issue on Facial Landmark Localisation "In-The-Wild". 2016. -# You can get the trained model file from: -# http://dlib.net/files/shape_predictor_68_face_landmarks.dat.bz2. -# Note that the license for the iBUG 300-W dataset excludes commercial use. -# So you should contact Imperial College London to find out if it's OK for -# you to use this model file in a commercial product. -# -# -# Also, note that you can train your own models using dlib's machine learning -# tools. See train_shape_predictor.py to see an example. -# -# -# COMPILING/INSTALLING THE DLIB PYTHON INTERFACE -# You can install dlib using the command: -# pip install dlib -# -# Alternatively, if you want to compile dlib yourself then go into the dlib -# root folder and run: -# python setup.py install -# or -# python setup.py install --yes USE_AVX_INSTRUCTIONS -# if you have a CPU that supports AVX instructions, since this makes some -# things run faster. -# -# Compiling dlib should work on any operating system so long as you have -# CMake installed. On Ubuntu, this can be done easily by running the -# command: -# sudo apt-get install cmake -# -# Also note that this example requires scikit-image which can be installed -# via the command: -# pip install scikit-image -# Or downloaded from http://scikit-image.org/download.html. - -import sys -import os -import dlib -import glob -from skimage import io - -if len(sys.argv) != 3: - print( - "Give the path to the trained shape predictor model as the first " - "argument and then the directory containing the facial images.\n" - "For example, if you are in the python_examples folder then " - "execute this program by running:\n" - " ./face_landmark_detection.py shape_predictor_68_face_landmarks.dat ../examples/faces\n" - "You can download a trained facial shape predictor from:\n" - " http://dlib.net/files/shape_predictor_68_face_landmarks.dat.bz2") - exit() - -predictor_path = sys.argv[1] -faces_folder_path = sys.argv[2] - -detector = dlib.get_frontal_face_detector() -predictor = dlib.shape_predictor(predictor_path) -win = dlib.image_window() - -for f in glob.glob(os.path.join(faces_folder_path, "*.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() diff --git a/ml/dlib/python_examples/face_recognition.py b/ml/dlib/python_examples/face_recognition.py deleted file mode 100755 index da2bdbc55..000000000 --- a/ml/dlib/python_examples/face_recognition.py +++ /dev/null @@ -1,123 +0,0 @@ -#!/usr/bin/python -# The contents of this file are in the public domain. See LICENSE_FOR_EXAMPLE_PROGRAMS.txt -# -# This example shows how to use dlib's face recognition tool. This tool maps -# an image of a human face to a 128 dimensional vector space where images of -# the same person are near to each other and images from different people are -# far apart. Therefore, you can perform face recognition by mapping faces to -# the 128D space and then checking if their Euclidean distance is small -# enough. -# -# When using a distance threshold of 0.6, the dlib model obtains an accuracy -# of 99.38% on the standard LFW face recognition benchmark, which is -# comparable to other state-of-the-art methods for face recognition as of -# February 2017. This accuracy means that, when presented with a pair of face -# images, the tool will correctly identify if the pair belongs to the same -# person or is from different people 99.38% of the time. -# -# Finally, for an in-depth discussion of how dlib's tool works you should -# refer to the C++ example program dnn_face_recognition_ex.cpp and the -# attendant documentation referenced therein. -# -# -# -# -# COMPILING/INSTALLING THE DLIB PYTHON INTERFACE -# You can install dlib using the command: -# pip install dlib -# -# Alternatively, if you want to compile dlib yourself then go into the dlib -# root folder and run: -# python setup.py install -# or -# python setup.py install --yes USE_AVX_INSTRUCTIONS -# if you have a CPU that supports AVX instructions, since this makes some -# things run faster. This code will also use CUDA if you have CUDA and cuDNN -# installed. -# -# Compiling dlib should work on any operating system so long as you have -# CMake installed. On Ubuntu, this can be done easily by running the -# command: -# sudo apt-get install cmake -# -# Also note that this example requires scikit-image which can be installed -# via the command: -# pip install scikit-image -# Or downloaded from http://scikit-image.org/download.html. - -import sys -import os -import dlib -import glob -from skimage import io - -if len(sys.argv) != 4: - print( - "Call this program like this:\n" - " ./face_recognition.py shape_predictor_5_face_landmarks.dat dlib_face_recognition_resnet_model_v1.dat ../examples/faces\n" - "You can download a trained facial shape predictor and recognition model from:\n" - " http://dlib.net/files/shape_predictor_5_face_landmarks.dat.bz2\n" - " http://dlib.net/files/dlib_face_recognition_resnet_model_v1.dat.bz2") - exit() - -predictor_path = sys.argv[1] -face_rec_model_path = sys.argv[2] -faces_folder_path = sys.argv[3] - -# Load all the models we need: a detector to find the faces, a shape predictor -# to find face landmarks so we can precisely localize the face, and finally the -# face recognition model. -detector = dlib.get_frontal_face_detector() -sp = dlib.shape_predictor(predictor_path) -facerec = dlib.face_recognition_model_v1(face_rec_model_path) - -win = dlib.image_window() - -# Now process all the images -for f in glob.glob(os.path.join(faces_folder_path, "*.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))) - - # Now process each face we found. - 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 = sp(img, d) - # Draw the face landmarks on the screen so we can see what face is currently being processed. - win.clear_overlay() - win.add_overlay(d) - win.add_overlay(shape) - - # Compute the 128D vector that describes the face in img identified by - # shape. In general, if two face descriptor vectors have a Euclidean - # distance between them less than 0.6 then they are from the same - # person, otherwise they are from different people. Here we just print - # the vector to the screen. - face_descriptor = facerec.compute_face_descriptor(img, shape) - print(face_descriptor) - # It should also be noted that you can also call this function like this: - # face_descriptor = facerec.compute_face_descriptor(img, shape, 100) - # The version of the call without the 100 gets 99.13% accuracy on LFW - # while the version with 100 gets 99.38%. However, the 100 makes the - # call 100x slower to execute, so choose whatever version you like. To - # explain a little, the 3rd argument tells the code how many times to - # jitter/resample the image. When you set it to 100 it executes the - # face descriptor extraction 100 times on slightly modified versions of - # the face and returns the average result. You could also pick a more - # middle value, such as 10, which is only 10x slower but still gets an - # LFW accuracy of 99.3%. - - - dlib.hit_enter_to_continue() - - diff --git a/ml/dlib/python_examples/find_candidate_object_locations.py b/ml/dlib/python_examples/find_candidate_object_locations.py deleted file mode 100755 index a5c386425..000000000 --- a/ml/dlib/python_examples/find_candidate_object_locations.py +++ /dev/null @@ -1,54 +0,0 @@ -#!/usr/bin/python -# -# This example shows how to use find_candidate_object_locations(). The -# function takes an input image and generates a set of candidate rectangles -# which are expected to bound any objects in the image. -# It is based on the paper: -# Segmentation as Selective Search for Object Recognition by Koen E. A. van de Sande, et al. -# -# Typically, you would use this as part of an object detection pipeline. -# find_candidate_object_locations() nominates boxes that might contain an -# object and you then run some expensive classifier on each one and throw away -# the false alarms. Since find_candidate_object_locations() will only generate -# a few thousand rectangles it is much faster than scanning all possible -# rectangles inside an image. -# -# -# COMPILING/INSTALLING THE DLIB PYTHON INTERFACE -# You can install dlib using the command: -# pip install dlib -# -# Alternatively, if you want to compile dlib yourself then go into the dlib -# root folder and run: -# python setup.py install -# or -# python setup.py install --yes USE_AVX_INSTRUCTIONS -# if you have a CPU that supports AVX instructions, since this makes some -# things run faster. -# -# Compiling dlib should work on any operating system so long as you have -# CMake installed. On Ubuntu, this can be done easily by running the -# command: -# sudo apt-get install cmake -# -# Also note that this example requires scikit-image which can be installed -# via the command: -# pip install scikit-image -# Or downloaded from http://scikit-image.org/download.html. - - - -import dlib -from skimage import io - -image_file = '../examples/faces/2009_004587.jpg' -img = io.imread(image_file) - -# Locations of candidate objects will be saved into rects -rects = [] -dlib.find_candidate_object_locations(img, rects, min_size=500) - -print("number of rectangles found {}".format(len(rects))) -for k, d in enumerate(rects): - print("Detection {}: Left: {} Top: {} Right: {} Bottom: {}".format( - k, d.left(), d.top(), d.right(), d.bottom())) diff --git a/ml/dlib/python_examples/global_optimization.py b/ml/dlib/python_examples/global_optimization.py deleted file mode 100755 index e3fb3f8cd..000000000 --- a/ml/dlib/python_examples/global_optimization.py +++ /dev/null @@ -1,47 +0,0 @@ -#!/usr/bin/python -# The contents of this file are in the public domain. See LICENSE_FOR_EXAMPLE_PROGRAMS.txt -# -# -# This is an example illustrating the use of the global optimization routine, -# find_min_global(), from the dlib C++ Library. This is a tool for finding the -# inputs to a function that result in the function giving its minimal output. -# This is a very useful tool for hyper parameter search when applying machine -# learning methods. There are also many other applications for this kind of -# general derivative free optimization. However, in this example program, we -# simply show how to call the method. For that, we use a common global -# optimization test function, as you can see below. -# -# -# COMPILING/INSTALLING THE DLIB PYTHON INTERFACE -# You can install dlib using the command: -# pip install dlib -# -# Alternatively, if you want to compile dlib yourself then go into the dlib -# root folder and run: -# python setup.py install -# -# Compiling dlib should work on any operating system so long as you have -# CMake installed. On Ubuntu, this can be done easily by running the -# command: -# sudo apt-get install cmake -# - -import dlib -from math import sin,cos,pi,exp,sqrt - -# This is a standard test function for these kinds of optimization problems. -# It has a bunch of local minima, with the global minimum resulting in -# holder_table()==-19.2085025679. -def holder_table(x0,x1): - return -abs(sin(x0)*cos(x1)*exp(abs(1-sqrt(x0*x0+x1*x1)/pi))) - -# Find the optimal inputs to holder_table(). The print statements that follow -# show that find_min_global() finds the optimal settings to high precision. -x,y = dlib.find_min_global(holder_table, - [-10,-10], # Lower bound constraints on x0 and x1 respectively - [10,10], # Upper bound constraints on x0 and x1 respectively - 80) # The number of times find_min_global() will call holder_table() - -print("optimal inputs: {}".format(x)); -print("optimal output: {}".format(y)); - diff --git a/ml/dlib/python_examples/max_cost_assignment.py b/ml/dlib/python_examples/max_cost_assignment.py deleted file mode 100755 index 8e284e6c8..000000000 --- a/ml/dlib/python_examples/max_cost_assignment.py +++ /dev/null @@ -1,57 +0,0 @@ -#!/usr/bin/python -# The contents of this file are in the public domain. See LICENSE_FOR_EXAMPLE_PROGRAMS.txt -# -# This simple example shows how to call dlib's optimal linear assignment -# problem solver. It is an implementation of the famous Hungarian algorithm -# and is quite fast, operating in O(N^3) time. -# -# COMPILING/INSTALLING THE DLIB PYTHON INTERFACE -# You can install dlib using the command: -# pip install dlib -# -# Alternatively, if you want to compile dlib yourself then go into the dlib -# root folder and run: -# python setup.py install -# or -# python setup.py install --yes USE_AVX_INSTRUCTIONS -# if you have a CPU that supports AVX instructions, since this makes some -# things run faster. -# -# Compiling dlib should work on any operating system so long as you have -# CMake installed. On Ubuntu, this can be done easily by running the -# command: -# sudo apt-get install cmake -# - -import dlib - -# Let's imagine you need to assign N people to N jobs. Additionally, each -# person will make your company a certain amount of money at each job, but each -# person has different skills so they are better at some jobs and worse at -# others. You would like to find the best way to assign people to these jobs. -# In particular, you would like to maximize the amount of money the group makes -# as a whole. This is an example of an assignment problem and is what is solved -# by the dlib.max_cost_assignment() routine. - -# So in this example, let's imagine we have 3 people and 3 jobs. We represent -# the amount of money each person will produce at each job with a cost matrix. -# Each row corresponds to a person and each column corresponds to a job. So for -# example, below we are saying that person 0 will make $1 at job 0, $2 at job 1, -# and $6 at job 2. -cost = dlib.matrix([[1, 2, 6], - [5, 3, 6], - [4, 5, 0]]) - -# To find out the best assignment of people to jobs we just need to call this -# function. -assignment = dlib.max_cost_assignment(cost) - -# This prints optimal assignments: [2, 0, 1] -# which indicates that we should assign the person from the first row of the -# cost matrix to job 2, the middle row person to job 0, and the bottom row -# person to job 1. -print("Optimal assignments: {}".format(assignment)) - -# This prints optimal cost: 16.0 -# which is correct since our optimal assignment is 6+5+5. -print("Optimal cost: {}".format(dlib.assignment_cost(cost, assignment))) diff --git a/ml/dlib/python_examples/requirements.txt b/ml/dlib/python_examples/requirements.txt deleted file mode 100644 index 8fa92c8a0..000000000 --- a/ml/dlib/python_examples/requirements.txt +++ /dev/null @@ -1,3 +0,0 @@ -scikit-image>=0.9.3 -opencv-python -numpy diff --git a/ml/dlib/python_examples/sequence_segmenter.py b/ml/dlib/python_examples/sequence_segmenter.py deleted file mode 100755 index 335e475f7..000000000 --- a/ml/dlib/python_examples/sequence_segmenter.py +++ /dev/null @@ -1,197 +0,0 @@ -#!/usr/bin/python -# The contents of this file are in the public domain. See LICENSE_FOR_EXAMPLE_PROGRAMS.txt -# -# This example shows how to use dlib to learn to do sequence segmentation. In -# a sequence segmentation task we are given a sequence of objects (e.g. words in -# a sentence) and we are supposed to detect certain subsequences (e.g. the names -# of people). Therefore, in the code below we create some very simple training -# sequences and use them to learn a sequence segmentation model. In particular, -# our sequences will be sentences represented as arrays of words and our task -# will be to learn to identify person names. Once we have our segmentation -# model we can use it to find names in new sentences, as we will show. -# -# COMPILING/INSTALLING THE DLIB PYTHON INTERFACE -# You can install dlib using the command: -# pip install dlib -# -# Alternatively, if you want to compile dlib yourself then go into the dlib -# root folder and run: -# python setup.py install -# or -# python setup.py install --yes USE_AVX_INSTRUCTIONS -# if you have a CPU that supports AVX instructions, since this makes some -# things run faster. -# -# Compiling dlib should work on any operating system so long as you have -# CMake installed. On Ubuntu, this can be done easily by running the -# command: -# sudo apt-get install cmake -# -import sys -import dlib - - -# The sequence segmentation models we work with in this example are chain -# structured conditional random field style models. Therefore, central to a -# sequence segmentation model is some method for converting the elements of a -# sequence into feature vectors. That is, while you might start out representing -# your sequence as an array of strings, the dlib interface works in terms of -# arrays of feature vectors. Each feature vector should capture important -# information about its corresponding element in the original raw sequence. So -# in this example, since we work with sequences of words and want to identify -# names, we will create feature vectors that tell us if the word is capitalized -# or not. In our simple data, this will be enough to identify names. -# Therefore, we define sentence_to_vectors() which takes a sentence represented -# as a string and converts it into an array of words and then associates a -# feature vector with each word. -def sentence_to_vectors(sentence): - # Create an empty array of vectors - vects = dlib.vectors() - for word in sentence.split(): - # Our vectors are very simple 1-dimensional vectors. The value of the - # single feature is 1 if the first letter of the word is capitalized and - # 0 otherwise. - if word[0].isupper(): - vects.append(dlib.vector([1])) - else: - vects.append(dlib.vector([0])) - return vects - - -# Dlib also supports the use of a sparse vector representation. This is more -# efficient than the above form when you have very high dimensional vectors that -# are mostly full of zeros. In dlib, each sparse vector is represented as an -# array of pair objects. Each pair contains an index and value. Any index not -# listed in the vector is implicitly associated with a value of zero. -# Additionally, when using sparse vectors with dlib.train_sequence_segmenter() -# you can use "unsorted" sparse vectors. This means you can add the index/value -# pairs into your sparse vectors in any order you want and don't need to worry -# about them being in sorted order. -def sentence_to_sparse_vectors(sentence): - vects = dlib.sparse_vectors() - has_cap = dlib.sparse_vector() - no_cap = dlib.sparse_vector() - # make has_cap equivalent to dlib.vector([1]) - has_cap.append(dlib.pair(0, 1)) - - # Since we didn't add anything to no_cap it is equivalent to - # dlib.vector([0]) - for word in sentence.split(): - if word[0].isupper(): - vects.append(has_cap) - else: - vects.append(no_cap) - return vects - - -def print_segment(sentence, names): - words = sentence.split() - for name in names: - for i in name: - sys.stdout.write(words[i] + " ") - sys.stdout.write("\n") - - - -# Now let's make some training data. Each example is a sentence as well as a -# set of ranges which indicate the locations of any names. -names = dlib.ranges() # make an array of dlib.range objects. -segments = dlib.rangess() # make an array of arrays of dlib.range objects. -sentences = [] - -sentences.append("The other day I saw a man named Jim Smith") -# We want to detect person names. So we note that the name is located within -# the range [8, 10). Note that we use half open ranges to identify segments. -# So in this case, the segment identifies the string "Jim Smith". -names.append(dlib.range(8, 10)) -segments.append(names) -names.clear() # make names empty for use again below - -sentences.append("Davis King is the main author of the dlib Library") -names.append(dlib.range(0, 2)) -segments.append(names) -names.clear() - -sentences.append("Bob Jones is a name and so is George Clinton") -names.append(dlib.range(0, 2)) -names.append(dlib.range(8, 10)) -segments.append(names) -names.clear() - -sentences.append("My dog is named Bob Barker") -names.append(dlib.range(4, 6)) -segments.append(names) -names.clear() - -sentences.append("ABC is an acronym but John James Smith is a name") -names.append(dlib.range(5, 8)) -segments.append(names) -names.clear() - -sentences.append("No names in this sentence at all") -segments.append(names) -names.clear() - - -# Now before we can pass these training sentences to the dlib tools we need to -# convert them into arrays of vectors as discussed above. We can use either a -# sparse or dense representation depending on our needs. In this example, we -# show how to do it both ways. -use_sparse_vects = False -if use_sparse_vects: - # Make an array of arrays of dlib.sparse_vector objects. - training_sequences = dlib.sparse_vectorss() - for s in sentences: - training_sequences.append(sentence_to_sparse_vectors(s)) -else: - # Make an array of arrays of dlib.vector objects. - training_sequences = dlib.vectorss() - for s in sentences: - training_sequences.append(sentence_to_vectors(s)) - -# Now that we have a simple training set we can train a sequence segmenter. -# However, the sequence segmentation trainer has some optional parameters we can -# set. These parameters determine properties of the segmentation model we will -# learn. See the dlib documentation for the sequence_segmenter object for a -# full discussion of their meanings. -params = dlib.segmenter_params() -params.window_size = 3 -params.use_high_order_features = True -params.use_BIO_model = True -# This is the common SVM C parameter. Larger values encourage the trainer to -# attempt to fit the data exactly but might overfit. In general, you determine -# this parameter by cross-validation. -params.C = 10 - -# Train a model. The model object is responsible for predicting the locations -# of names in new sentences. -model = dlib.train_sequence_segmenter(training_sequences, segments, params) - -# Let's print out the things the model thinks are names. The output is a set -# of ranges which are predicted to contain names. If you run this example -# program you will see that it gets them all correct. -for i, s in enumerate(sentences): - print_segment(s, model(training_sequences[i])) - -# Let's also try segmenting a new sentence. This will print out "Bob Bucket". -# Note that we need to remember to use the same vector representation as we used -# during training. -test_sentence = "There once was a man from Nantucket " \ - "whose name rhymed with Bob Bucket" -if use_sparse_vects: - print_segment(test_sentence, - model(sentence_to_sparse_vectors(test_sentence))) -else: - print_segment(test_sentence, model(sentence_to_vectors(test_sentence))) - -# We can also measure the accuracy of a model relative to some labeled data. -# This statement prints the precision, recall, and F1-score of the model -# relative to the data in training_sequences/segments. -print("Test on training data: {}".format( - dlib.test_sequence_segmenter(model, training_sequences, segments))) - -# We can also do 5-fold cross-validation and print the resulting precision, -# recall, and F1-score. -print("Cross validation: {}".format( - dlib.cross_validate_sequence_segmenter(training_sequences, segments, 5, - params))) diff --git a/ml/dlib/python_examples/svm_binary_classifier.py b/ml/dlib/python_examples/svm_binary_classifier.py deleted file mode 100755 index d114c815a..000000000 --- a/ml/dlib/python_examples/svm_binary_classifier.py +++ /dev/null @@ -1,68 +0,0 @@ -#!/usr/bin/python -# The contents of this file are in the public domain. See LICENSE_FOR_EXAMPLE_PROGRAMS.txt -# -# -# This is an example illustrating the use of a binary SVM classifier tool from -# the dlib C++ Library. In this example, we will create a simple test dataset -# and show how to learn a classifier from it. -# -# -# COMPILING/INSTALLING THE DLIB PYTHON INTERFACE -# You can install dlib using the command: -# pip install dlib -# -# Alternatively, if you want to compile dlib yourself then go into the dlib -# root folder and run: -# python setup.py install -# or -# python setup.py install --yes USE_AVX_INSTRUCTIONS -# if you have a CPU that supports AVX instructions, since this makes some -# things run faster. -# -# Compiling dlib should work on any operating system so long as you have -# CMake installed. On Ubuntu, this can be done easily by running the -# command: -# sudo apt-get install cmake -# - -import dlib -try: - import cPickle as pickle -except ImportError: - import pickle - -x = dlib.vectors() -y = dlib.array() - -# Make a training dataset. Here we have just two training examples. Normally -# you would use a much larger training dataset, but for the purpose of example -# this is plenty. For binary classification, the y labels should all be either +1 or -1. -x.append(dlib.vector([1, 2, 3, -1, -2, -3])) -y.append(+1) - -x.append(dlib.vector([-1, -2, -3, 1, 2, 3])) -y.append(-1) - - -# Now make a training object. This object is responsible for turning a -# training dataset into a prediction model. This one here is a SVM trainer -# that uses a linear kernel. If you wanted to use a RBF kernel or histogram -# intersection kernel you could change it to one of these lines: -# svm = dlib.svm_c_trainer_histogram_intersection() -# svm = dlib.svm_c_trainer_radial_basis() -svm = dlib.svm_c_trainer_linear() -svm.be_verbose() -svm.set_c(10) - -# Now train the model. The return value is the trained model capable of making predictions. -classifier = svm.train(x, y) - -# Now run the model on our data and look at the results. -print("prediction for first sample: {}".format(classifier(x[0]))) -print("prediction for second sample: {}".format(classifier(x[1]))) - - -# classifier models can also be pickled in the same was as any other python object. -with open('saved_model.pickle', 'wb') as handle: - pickle.dump(classifier, handle, 2) - diff --git a/ml/dlib/python_examples/svm_rank.py b/ml/dlib/python_examples/svm_rank.py deleted file mode 100755 index dad642274..000000000 --- a/ml/dlib/python_examples/svm_rank.py +++ /dev/null @@ -1,155 +0,0 @@ -#!/usr/bin/python -# The contents of this file are in the public domain. See LICENSE_FOR_EXAMPLE_PROGRAMS.txt -# -# -# This is an example illustrating the use of the SVM-Rank tool from the dlib C++ -# Library. This is a tool useful for learning to rank objects. For example, -# you might use it to learn to rank web pages in response to a user's query. -# The idea being to rank the most relevant pages higher than non-relevant pages. -# -# In this example, we will create a simple test dataset and show how to learn a -# ranking function from it. The purpose of the function will be to give -# "relevant" objects higher scores than "non-relevant" objects. The idea is -# that you use this score to order the objects so that the most relevant objects -# come to the top of the ranked list. -# -# -# COMPILING/INSTALLING THE DLIB PYTHON INTERFACE -# You can install dlib using the command: -# pip install dlib -# -# Alternatively, if you want to compile dlib yourself then go into the dlib -# root folder and run: -# python setup.py install -# or -# python setup.py install --yes USE_AVX_INSTRUCTIONS -# if you have a CPU that supports AVX instructions, since this makes some -# things run faster. -# -# Compiling dlib should work on any operating system so long as you have -# CMake installed. On Ubuntu, this can be done easily by running the -# command: -# sudo apt-get install cmake -# - -import dlib - - -# Now let's make some testing data. To make it really simple, let's suppose -# that we are ranking 2D vectors and that vectors with positive values in the -# first dimension should rank higher than other vectors. So what we do is make -# examples of relevant (i.e. high ranking) and non-relevant (i.e. low ranking) -# vectors and store them into a ranking_pair object like so: -data = dlib.ranking_pair() -# Here we add two examples. In real applications, you would want lots of -# examples of relevant and non-relevant vectors. -data.relevant.append(dlib.vector([1, 0])) -data.nonrelevant.append(dlib.vector([0, 1])) - -# Now that we have some data, we can use a machine learning method to learn a -# function that will give high scores to the relevant vectors and low scores to -# the non-relevant vectors. -trainer = dlib.svm_rank_trainer() -# Note that the trainer object has some parameters that control how it behaves. -# For example, since this is the SVM-Rank algorithm it has a C parameter that -# controls the trade-off between trying to fit the training data exactly or -# selecting a "simpler" solution which might generalize better. -trainer.c = 10 - -# So let's do the training. -rank = trainer.train(data) - -# Now if you call rank on a vector it will output a ranking score. In -# particular, the ranking score for relevant vectors should be larger than the -# score for non-relevant vectors. -print("Ranking score for a relevant vector: {}".format( - rank(data.relevant[0]))) -print("Ranking score for a non-relevant vector: {}".format( - rank(data.nonrelevant[0]))) -# The output is the following: -# ranking score for a relevant vector: 0.5 -# ranking score for a non-relevant vector: -0.5 - - -# If we want an overall measure of ranking accuracy we can compute the ordering -# accuracy and mean average precision values by calling test_ranking_function(). -# In this case, the ordering accuracy tells us how often a non-relevant vector -# was ranked ahead of a relevant vector. In this case, it returns 1 for both -# metrics, indicating that the rank function outputs a perfect ranking. -print(dlib.test_ranking_function(rank, data)) - -# The ranking scores are computed by taking the dot product between a learned -# weight vector and a data vector. If you want to see the learned weight vector -# you can display it like so: -print("Weights: {}".format(rank.weights)) -# In this case the weights are: -# 0.5 -# -0.5 - -# In the above example, our data contains just two sets of objects. The -# relevant set and non-relevant set. The trainer is attempting to find a -# ranking function that gives every relevant vector a higher score than every -# non-relevant vector. Sometimes what you want to do is a little more complex -# than this. -# -# For example, in the web page ranking example we have to rank pages based on a -# user's query. In this case, each query will have its own set of relevant and -# non-relevant documents. What might be relevant to one query may well be -# non-relevant to another. So in this case we don't have a single global set of -# relevant web pages and another set of non-relevant web pages. -# -# To handle cases like this, we can simply give multiple ranking_pair instances -# to the trainer. Therefore, each ranking_pair would represent the -# relevant/non-relevant sets for a particular query. An example is shown below -# (for simplicity, we reuse our data from above to make 4 identical "queries"). -queries = dlib.ranking_pairs() -queries.append(data) -queries.append(data) -queries.append(data) -queries.append(data) - -# We can train just as before. -rank = trainer.train(queries) - -# Now that we have multiple ranking_pair instances, we can also use -# cross_validate_ranking_trainer(). This performs cross-validation by splitting -# the queries up into folds. That is, it lets the trainer train on a subset of -# ranking_pair instances and tests on the rest. It does this over 4 different -# splits and returns the overall ranking accuracy based on the held out data. -# Just like test_ranking_function(), it reports both the ordering accuracy and -# mean average precision. -print("Cross validation results: {}".format( - dlib.cross_validate_ranking_trainer(trainer, queries, 4))) - -# Finally, note that the ranking tools also support the use of sparse vectors in -# addition to dense vectors (which we used above). So if we wanted to do -# exactly what we did in the first part of the example program above but using -# sparse vectors we would do it like so: - -data = dlib.sparse_ranking_pair() -samp = dlib.sparse_vector() - -# Make samp represent the same vector as dlib.vector([1, 0]). In dlib, a sparse -# vector is just an array of pair objects. Each pair stores an index and a -# value. Moreover, the svm-ranking tools require sparse vectors to be sorted -# and to have unique indices. This means that the indices are listed in -# increasing order and no index value shows up more than once. If necessary, -# you can use the dlib.make_sparse_vector() routine to make a sparse vector -# object properly sorted and contain unique indices. -samp.append(dlib.pair(0, 1)) -data.relevant.append(samp) - -# Now make samp represent the same vector as dlib.vector([0, 1]) -samp.clear() -samp.append(dlib.pair(1, 1)) -data.nonrelevant.append(samp) - -trainer = dlib.svm_rank_trainer_sparse() -rank = trainer.train(data) -print("Ranking score for a relevant vector: {}".format( - rank(data.relevant[0]))) -print("Ranking score for a non-relevant vector: {}".format( - rank(data.nonrelevant[0]))) -# Just as before, the output is the following: -# ranking score for a relevant vector: 0.5 -# ranking score for a non-relevant vector: -0.5 diff --git a/ml/dlib/python_examples/svm_struct.py b/ml/dlib/python_examples/svm_struct.py deleted file mode 100755 index 7f0004ccd..000000000 --- a/ml/dlib/python_examples/svm_struct.py +++ /dev/null @@ -1,343 +0,0 @@ -#!/usr/bin/python -# The contents of this file are in the public domain. See LICENSE_FOR_EXAMPLE_PROGRAMS.txt -# -# This is an example illustrating the use of the structural SVM solver from -# the dlib C++ Library. Therefore, this example teaches you the central ideas -# needed to setup a structural SVM model for your machine learning problems. To -# illustrate the process, we use dlib's structural SVM solver to learn the -# parameters of a simple multi-class classifier. We first discuss the -# multi-class classifier model and then walk through using the structural SVM -# tools to find the parameters of this classification model. As an aside, -# dlib's C++ interface to the structural SVM solver is threaded. So on a -# multi-core computer it is significantly faster than using the python -# interface. So consider using the C++ interface instead if you find that -# running it in python is slow. -# -# -# COMPILING/INSTALLING THE DLIB PYTHON INTERFACE -# You can install dlib using the command: -# pip install dlib -# -# Alternatively, if you want to compile dlib yourself then go into the dlib -# root folder and run: -# python setup.py install -# or -# python setup.py install --yes USE_AVX_INSTRUCTIONS -# if you have a CPU that supports AVX instructions, since this makes some -# things run faster. -# -# Compiling dlib should work on any operating system so long as you have -# CMake installed. On Ubuntu, this can be done easily by running the -# command: -# sudo apt-get install cmake -# - -import dlib - - -def main(): - # In this example, we have three types of samples: class 0, 1, or 2. That - # is, each of our sample vectors falls into one of three classes. To keep - # this example very simple, each sample vector is zero everywhere except at - # one place. The non-zero dimension of each vector determines the class of - # the vector. So for example, the first element of samples has a class of 1 - # because samples[0][1] is the only non-zero element of samples[0]. - samples = [[0, 2, 0], [1, 0, 0], [0, 4, 0], [0, 0, 3]] - # Since we want to use a machine learning method to learn a 3-class - # classifier we need to record the labels of our samples. Here samples[i] - # has a class label of labels[i]. - labels = [1, 0, 1, 2] - - # Now that we have some training data we can tell the structural SVM to - # learn the parameters of our 3-class classifier model. The details of this - # will be explained later. For now, just note that it finds the weights - # (i.e. a vector of real valued parameters) such that predict_label(weights, - # sample) always returns the correct label for a sample vector. - problem = ThreeClassClassifierProblem(samples, labels) - weights = dlib.solve_structural_svm_problem(problem) - - # Print the weights and then evaluate predict_label() on each of our - # training samples. Note that the correct label is predicted for each - # sample. - print(weights) - for k, s in enumerate(samples): - print("Predicted label for sample[{0}]: {1}".format( - k, predict_label(weights, s))) - - -def predict_label(weights, sample): - """Given the 9-dimensional weight vector which defines a 3 class classifier, - predict the class of the given 3-dimensional sample vector. Therefore, the - output of this function is either 0, 1, or 2 (i.e. one of the three possible - labels).""" - - # Our 3-class classifier model can be thought of as containing 3 separate - # linear classifiers. So to predict the class of a sample vector we - # evaluate each of these three classifiers and then whatever classifier has - # the largest output "wins" and predicts the label of the sample. This is - # the popular one-vs-all multi-class classifier model. - # Keeping this in mind, the code below simply pulls the three separate - # weight vectors out of weights and then evaluates each against sample. The - # individual classifier scores are stored in scores and the highest scoring - # index is returned as the label. - w0 = weights[0:3] - w1 = weights[3:6] - w2 = weights[6:9] - scores = [dot(w0, sample), dot(w1, sample), dot(w2, sample)] - max_scoring_label = scores.index(max(scores)) - return max_scoring_label - - -def dot(a, b): - """Compute the dot product between the two vectors a and b.""" - return sum(i * j for i, j in zip(a, b)) - - -################################################################################ - - -class ThreeClassClassifierProblem: - # Now we arrive at the meat of this example program. To use the - # dlib.solve_structural_svm_problem() routine you need to define an object - # which tells the structural SVM solver what to do for your problem. In - # this example, this is done by defining the ThreeClassClassifierProblem - # object. Before we get into the details, we first discuss some background - # information on structural SVMs. - # - # A structural SVM is a supervised machine learning method for learning to - # predict complex outputs. This is contrasted with a binary classifier - # which makes only simple yes/no predictions. A structural SVM, on the - # other hand, can learn to predict complex outputs such as entire parse - # trees or DNA sequence alignments. To do this, it learns a function F(x,y) - # which measures how well a particular data sample x matches a label y, - # where a label is potentially a complex thing like a parse tree. However, - # to keep this example program simple we use only a 3 category label output. - # - # At test time, the best label for a new x is given by the y which - # maximizes F(x,y). To put this into the context of the current example, - # F(x,y) computes the score for a given sample and class label. The - # predicted class label is therefore whatever value of y which makes F(x,y) - # the biggest. This is exactly what predict_label() does. That is, it - # computes F(x,0), F(x,1), and F(x,2) and then reports which label has the - # biggest value. - # - # At a high level, a structural SVM can be thought of as searching the - # parameter space of F(x,y) for the set of parameters that make the - # following inequality true as often as possible: - # F(x_i,y_i) > max{over all incorrect labels of x_i} F(x_i, y_incorrect) - # That is, it seeks to find the parameter vector such that F(x,y) always - # gives the highest score to the correct output. To define the structural - # SVM optimization problem precisely, we first introduce some notation: - # - let PSI(x,y) == the joint feature vector for input x and a label y - # - let F(x,y|w) == dot(w,PSI(x,y)). - # (we use the | notation to emphasize that F() has the parameter vector - # of weights called w) - # - let LOSS(idx,y) == the loss incurred for predicting that the - # idx-th training sample has a label of y. Note that LOSS() - # should always be >= 0 and should become exactly 0 when y is the - # correct label for the idx-th sample. Moreover, it should notionally - # indicate how bad it is to predict y for the idx'th sample. - # - let x_i == the i-th training sample. - # - let y_i == the correct label for the i-th training sample. - # - The number of data samples is N. - # - # Then the optimization problem solved by a structural SVM using - # dlib.solve_structural_svm_problem() is the following: - # Minimize: h(w) == 0.5*dot(w,w) + C*R(w) - # - # Where R(w) == sum from i=1 to N: 1/N * sample_risk(i,w) and - # sample_risk(i,w) == max over all - # Y: LOSS(i,Y) + F(x_i,Y|w) - F(x_i,y_i|w) and C > 0 - # - # You can think of the sample_risk(i,w) as measuring the degree of error - # you would make when predicting the label of the i-th sample using - # parameters w. That is, it is zero only when the correct label would be - # predicted and grows larger the more "wrong" the predicted output becomes. - # Therefore, the objective function is minimizing a balance between making - # the weights small (typically this reduces overfitting) and fitting the - # training data. The degree to which you try to fit the data is controlled - # by the C parameter. - # - # For a more detailed introduction to structured support vector machines - # you should consult the following paper: - # Predicting Structured Objects with Support Vector Machines by - # Thorsten Joachims, Thomas Hofmann, Yisong Yue, and Chun-nam Yu - # - - # Finally, we come back to the code. To use - # dlib.solve_structural_svm_problem() you need to provide the things - # discussed above. This is the value of C, the number of training samples, - # the dimensionality of PSI(), as well as methods for calculating the loss - # values and PSI() vectors. You will also need to write code that can - # compute: - # max over all Y: LOSS(i,Y) + F(x_i,Y|w). To summarize, the - # ThreeClassClassifierProblem class is required to have the following - # fields: - # - C - # - num_samples - # - num_dimensions - # - get_truth_joint_feature_vector() - # - separation_oracle() - - C = 1 - - # There are also a number of optional arguments: - # epsilon is the stopping tolerance. The optimizer will run until R(w) is - # within epsilon of its optimal value. If you don't set this then it - # defaults to 0.001. - # epsilon = 1e-13 - - # Uncomment this and the optimizer will print its progress to standard - # out. You will be able to see things like the current risk gap. The - # optimizer continues until the - # risk gap is below epsilon. - # be_verbose = True - - # If you want to require that the learned weights are all non-negative - # then set this field to True. - # learns_nonnegative_weights = True - - # The optimizer uses an internal cache to avoid unnecessary calls to your - # separation_oracle() routine. This parameter controls the size of that - # cache. Bigger values use more RAM and might make the optimizer run - # faster. You can also disable it by setting it to 0 which is good to do - # when your separation_oracle is very fast. If If you don't call this - # function it defaults to a value of 5. - # max_cache_size = 20 - - def __init__(self, samples, labels): - # dlib.solve_structural_svm_problem() expects the class to have - # num_samples and num_dimensions fields. These fields should contain - # the number of training samples and the dimensionality of the PSI - # feature vector respectively. - self.num_samples = len(samples) - self.num_dimensions = len(samples[0])*3 - - self.samples = samples - self.labels = labels - - def make_psi(self, x, label): - """Compute PSI(x,label).""" - # All we are doing here is taking x, which is a 3 dimensional sample - # vector in this example program, and putting it into one of 3 places in - # a 9 dimensional PSI vector, which we then return. So this function - # returns PSI(x,label). To see why we setup PSI like this, recall how - # predict_label() works. It takes in a 9 dimensional weight vector and - # breaks the vector into 3 pieces. Each piece then defines a different - # classifier and we use them in a one-vs-all manner to predict the - # label. So now that we are in the structural SVM code we have to - # define the PSI vector to correspond to this usage. That is, we need - # to setup PSI so that argmax_y dot(weights,PSI(x,y)) == - # predict_label(weights,x). This is how we tell the structural SVM - # solver what kind of problem we are trying to solve. - # - # It's worth emphasizing that the single biggest step in using a - # structural SVM is deciding how you want to represent PSI(x,label). It - # is always a vector, but deciding what to put into it to solve your - # problem is often not a trivial task. Part of the difficulty is that - # you need an efficient method for finding the label that makes - # dot(w,PSI(x,label)) the biggest. Sometimes this is easy, but often - # finding the max scoring label turns into a difficult combinatorial - # optimization problem. So you need to pick a PSI that doesn't make the - # label maximization step intractable but also still well models your - # problem. - # - # Create a dense vector object (note that you can also use unsorted - # sparse vectors (i.e. dlib.sparse_vector objects) to represent your - # PSI vector. This is useful if you have very high dimensional PSI - # vectors that are mostly zeros. In the context of this example, you - # would simply return a dlib.sparse_vector at the end of make_psi() and - # the rest of the example would still work properly. ). - psi = dlib.vector() - # Set it to have 9 dimensions. Note that the elements of the vector - # are 0 initialized. - psi.resize(self.num_dimensions) - dims = len(x) - if label == 0: - for i in range(0, dims): - psi[i] = x[i] - elif label == 1: - for i in range(dims, 2 * dims): - psi[i] = x[i - dims] - else: # the label must be 2 - for i in range(2 * dims, 3 * dims): - psi[i] = x[i - 2 * dims] - return psi - - # Now we get to the two member functions that are directly called by - # dlib.solve_structural_svm_problem(). - # - # In get_truth_joint_feature_vector(), all you have to do is return the - # PSI() vector for the idx-th training sample when it has its true label. - # So here it returns - # PSI(self.samples[idx], self.labels[idx]). - def get_truth_joint_feature_vector(self, idx): - return self.make_psi(self.samples[idx], self.labels[idx]) - - # separation_oracle() is more interesting. - # dlib.solve_structural_svm_problem() will call separation_oracle() many - # times during the optimization. Each time it will give it the current - # value of the parameter weights and the separation_oracle() is supposed to - # find the label that most violates the structural SVM objective function - # for the idx-th sample. Then the separation oracle reports the - # corresponding PSI vector and loss value. To state this more precisely, - # the separation_oracle() member function has the following contract: - # requires - # - 0 <= idx < self.num_samples - # - len(current_solution) == self.num_dimensions - # ensures - # - runs the separation oracle on the idx-th sample. - # We define this as follows: - # - let X == the idx-th training sample. - # - let PSI(X,y) == the joint feature vector for input X - # and an arbitrary label y. - # - let F(X,y) == dot(current_solution,PSI(X,y)). - # - let LOSS(idx,y) == the loss incurred for predicting that the - # idx-th sample has a label of y. Note that LOSS() - # should always be >= 0 and should become exactly 0 when y is the - # correct label for the idx-th sample. - # - # Then the separation oracle finds a Y such that: - # Y = argmax over all y: LOSS(idx,y) + F(X,y) - # (i.e. It finds the label which maximizes the above expression.) - # - # Finally, separation_oracle() returns LOSS(idx,Y),PSI(X,Y) - def separation_oracle(self, idx, current_solution): - samp = self.samples[idx] - dims = len(samp) - scores = [0, 0, 0] - # compute scores for each of the three classifiers - scores[0] = dot(current_solution[0:dims], samp) - scores[1] = dot(current_solution[dims:2*dims], samp) - scores[2] = dot(current_solution[2*dims:3*dims], samp) - - # Add in the loss-augmentation. Recall that we maximize - # LOSS(idx,y) + F(X,y) in the separate oracle, not just F(X,y) as we - # normally would in predict_label(). Therefore, we must add in this - # extra amount to account for the loss-augmentation. For our simple - # multi-class classifier, we incur a loss of 1 if we don't predict the - # correct label and a loss of 0 if we get the right label. - if self.labels[idx] != 0: - scores[0] += 1 - if self.labels[idx] != 1: - scores[1] += 1 - if self.labels[idx] != 2: - scores[2] += 1 - - # Now figure out which classifier has the largest loss-augmented score. - max_scoring_label = scores.index(max(scores)) - # And finally record the loss that was associated with that predicted - # label. Again, the loss is 1 if the label is incorrect and 0 otherwise. - if max_scoring_label == self.labels[idx]: - loss = 0 - else: - loss = 1 - - # Finally, return the loss and PSI vector corresponding to the label - # we just found. - psi = self.make_psi(samp, max_scoring_label) - return loss, psi - - -if __name__ == "__main__": - main() diff --git a/ml/dlib/python_examples/train_object_detector.py b/ml/dlib/python_examples/train_object_detector.py deleted file mode 100755 index aef3fe16d..000000000 --- a/ml/dlib/python_examples/train_object_detector.py +++ /dev/null @@ -1,183 +0,0 @@ -#!/usr/bin/python -# The contents of this file are in the public domain. See LICENSE_FOR_EXAMPLE_PROGRAMS.txt -# -# This example program shows how you can use dlib to make a HOG based object -# detector for things like faces, pedestrians, and any other semi-rigid -# object. In particular, we go though the steps to train the kind of sliding -# window object detector first published by Dalal and Triggs in 2005 in the -# paper Histograms of Oriented Gradients for Human Detection. -# -# -# COMPILING/INSTALLING THE DLIB PYTHON INTERFACE -# You can install dlib using the command: -# pip install dlib -# -# Alternatively, if you want to compile dlib yourself then go into the dlib -# root folder and run: -# python setup.py install -# or -# python setup.py install --yes USE_AVX_INSTRUCTIONS -# if you have a CPU that supports AVX instructions, since this makes some -# things run faster. -# -# Compiling dlib should work on any operating system so long as you have -# CMake installed. On Ubuntu, this can be done easily by running the -# command: -# sudo apt-get install cmake -# -# Also note that this example requires scikit-image which can be installed -# via the command: -# pip install scikit-image -# Or downloaded from http://scikit-image.org/download.html. - -import os -import sys -import glob - -import dlib -from skimage import io - - -# 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. -if len(sys.argv) != 2: - print( - "Give the path to the examples/faces directory as the argument to this " - "program. For example, if you are in the python_examples folder then " - "execute this program by running:\n" - " ./train_object_detector.py ../examples/faces") - exit() -faces_folder = sys.argv[1] - - -# Now let's do the training. The train_simple_object_detector() function has a -# bunch of options, all of which come with reasonable default values. The next -# few lines goes over some of these options. -options = dlib.simple_object_detector_training_options() -# Since faces are left/right symmetric we can tell the trainer to train a -# symmetric detector. This helps it get the most value out of the training -# data. -options.add_left_right_image_flips = True -# The trainer is a kind of support vector machine and therefore has the usual -# SVM C parameter. In general, a bigger C encourages it to fit the training -# data better but might lead to overfitting. You must find the best C value -# empirically by checking how well the trained detector works on a test set of -# images you haven't trained on. Don't just leave the value set at 5. Try a -# few different C values and see what works best for your data. -options.C = 5 -# Tell the code how many CPU cores your computer has for the fastest training. -options.num_threads = 4 -options.be_verbose = True - - -training_xml_path = os.path.join(faces_folder, "training.xml") -testing_xml_path = os.path.join(faces_folder, "testing.xml") -# This function does the actual training. It will save the final detector to -# detector.svm. The input is an XML file that lists the images in the training -# dataset and also contains the positions of the face boxes. To create your -# own XML files you can use the imglab tool which can be found in the -# tools/imglab folder. It is a simple graphical tool for labeling objects in -# 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. -dlib.train_simple_object_detector(training_xml_path, "detector.svm", 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 -print("Training accuracy: {}".format( - dlib.test_simple_object_detector(training_xml_path, "detector.svm"))) -# 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, "detector.svm"))) - - - - - -# Now let's use the detector as you would in a normal application. First we -# will load it from disk. -detector = dlib.simple_object_detector("detector.svm") - -# We can look at the HOG filter we learned. It should look like a face. Neat! -win_det = dlib.image_window() -win_det.set_image(detector) - -# Now let's run the detector over the images in the faces folder and display the -# results. -print("Showing detections 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) - dets = detector(img) - 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())) - - win.clear_overlay() - win.set_image(img) - win.add_overlay(dets) - dlib.hit_enter_to_continue() - - - - -# Next, suppose you have trained multiple detectors and you want to run them -# efficiently as a group. You can do this as follows: -detector1 = dlib.fhog_object_detector("detector.svm") -# In this example we load detector.svm again since it's the only one we have on -# hand. But in general it would be a different detector. -detector2 = dlib.fhog_object_detector("detector.svm") -# make a list of all the detectors you wan to run. Here we have 2, but you -# could have any number. -detectors = [detector1, detector2] -image = io.imread(faces_folder + '/2008_002506.jpg'); -[boxes, confidences, detector_idxs] = dlib.fhog_object_detector.run_multiple(detectors, image, upsample_num_times=1, adjust_threshold=0.0) -for i in range(len(boxes)): - print("detector {} found box {} with confidence {}.".format(detector_idxs[i], boxes[i], confidences[i])) - - - - -# Finally, note that you don't have to use the XML based input to -# train_simple_object_detector(). If you have already loaded your training -# images and bounding boxes for the objects then you can call it as shown -# below. - -# You just need to put your images into a list. -images = [io.imread(faces_folder + '/2008_002506.jpg'), - io.imread(faces_folder + '/2009_004587.jpg')] -# Then for each image you make a list of rectangles which give the pixel -# locations of the edges of the boxes. -boxes_img1 = ([dlib.rectangle(left=329, top=78, right=437, bottom=186), - dlib.rectangle(left=224, top=95, right=314, bottom=185), - dlib.rectangle(left=125, top=65, right=214, bottom=155)]) -boxes_img2 = ([dlib.rectangle(left=154, top=46, right=228, bottom=121), - dlib.rectangle(left=266, top=280, right=328, bottom=342)]) -# And then you aggregate those lists of boxes into one big list and then call -# train_simple_object_detector(). -boxes = [boxes_img1, boxes_img2] - -detector2 = dlib.train_simple_object_detector(images, boxes, options) -# We could save this detector to disk by uncommenting the following. -#detector2.save('detector2.svm') - -# Now let's look at its HOG filter! -win_det.set_image(detector2) -dlib.hit_enter_to_continue() - -# Note that you don't have to use the XML based input to -# test_simple_object_detector(). If you have already loaded your training -# images and bounding boxes for the objects then you can call it as shown -# below. -print("\nTraining accuracy: {}".format( - dlib.test_simple_object_detector(images, boxes, detector2))) diff --git a/ml/dlib/python_examples/train_shape_predictor.py b/ml/dlib/python_examples/train_shape_predictor.py deleted file mode 100755 index 23758b2ce..000000000 --- a/ml/dlib/python_examples/train_shape_predictor.py +++ /dev/null @@ -1,135 +0,0 @@ -#!/usr/bin/python -# The contents of this file are in the public domain. See LICENSE_FOR_EXAMPLE_PROGRAMS.txt -# -# This example program shows how to use dlib's implementation of the paper: -# One Millisecond Face Alignment with an Ensemble of Regression Trees by -# Vahid Kazemi and Josephine Sullivan, CVPR 2014 -# -# In particular, we will train a face landmarking model based on a small -# dataset and then evaluate it. If you want to visualize the output of the -# trained model on some images then you can run the -# face_landmark_detection.py example program with predictor.dat as the input -# model. -# -# It should also be noted that this kind of model, while often used for face -# landmarking, is quite general and can be used for a variety of shape -# prediction tasks. But here we demonstrate it only on a simple face -# landmarking task. -# -# COMPILING/INSTALLING THE DLIB PYTHON INTERFACE -# You can install dlib using the command: -# pip install dlib -# -# Alternatively, if you want to compile dlib yourself then go into the dlib -# root folder and run: -# python setup.py install -# or -# python setup.py install --yes USE_AVX_INSTRUCTIONS -# if you have a CPU that supports AVX instructions, since this makes some -# things run faster. -# -# Compiling dlib should work on any operating system so long as you have -# CMake installed. On Ubuntu, this can be done easily by running the -# command: -# sudo apt-get install cmake -# -# Also note that this example requires scikit-image which can be installed -# via the command: -# pip install scikit-image -# Or downloaded from http://scikit-image.org/download.html. - -import os -import sys -import glob - -import dlib -from skimage import io - - -# 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. -if len(sys.argv) != 2: - print( - "Give the path to the examples/faces directory as the argument to this " - "program. For example, if you are in the python_examples folder then " - "execute this program by running:\n" - " ./train_shape_predictor.py ../examples/faces") - exit() -faces_folder = sys.argv[1] - -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 = 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(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 -# 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() - |