def train_dlib_detector(self):
# 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 # seems to degrade performance in this case
# 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 = 9
# Tell the code how many CPU cores your computer has for the fastest training.
options.num_threads = 4
options.be_verbose = True
options.upsample_limit = 2
# 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.
#options.detection_window_size = 60 * 80
options.detection_window_size = int((50 * 70)) # 468, 1.44
dlib.train_simple_object_detector("../data/annotations/bb/training/combined_mtb.xml", "../data/models/detector_mtb.svm", options)
options.detection_window_size = int((40 * 90)) # 448, 2.29
dlib.train_simple_object_detector("../data/annotations/bb/training/combined_ped.xml", "../data/models/detector_ped.svm", options)
def train(request):
import os
import sys
import glob
import dlib
from skimage import io
# 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 = 3
# Tell the code how many CPU cores your computer has for the fastest training.
options.num_threads = multiprocessing.cpu_count()
options.be_verbose = True
training_xml_path = os.path.join(settings.BASE_DIR, "training.xml")
dlib.train_simple_object_detector(training_xml_path, "detector.svm", options)
return HttpResponse('{"status": "completed"}', content_type="application/json")
def test_train_xml_detector(self):
# This effectively tests that we can successfully load images
options = dlib.simple_object_detector_training_options()
options.add_left_right_image_flips = True
options.C = 1
options.num_threads = 1
dlib.train_simple_object_detector(self.images_xml_path, './test.svm',
options)
self.assertTrue(os.path.exists('./test.svm'))
def train_with_dlib(self, obj_folder, detector_path, train_file_name, test_file_name):
pdb.set_trace()
logger = MyUtils.Tee("{0}/{1}.log".format(obj_folder, 'run'), 'w')
logger.write('tee: dlib training called')
logger.write('dlib training called')
# 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()
# 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 = 2
options.be_verbose = True
training_xml_path = os.path.join(obj_folder, train_file_name)
testing_xml_path = os.path.join(obj_folder, test_file_name)
# 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.
logger.write('start training. saved detector path: ' + detector_path)
dlib.train_simple_object_detector(training_xml_path, detector_path, options)
logger.write( 'end training')
# Now that we have a face detector we can test it. The first statement tests
# it on the training data. It will logger.write((the precision, recall, and then)
# average precision.
logger.write("") # Print blank line to create gap from previous output
logger.write("Training accuracy: {}".format(
dlib.test_simple_object_detector(training_xml_path, detector_path)))
# 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.
accuracy = dlib.test_simple_object_detector(testing_xml_path, "detector.svm")
logger.write("Testing accuracy: {}".format(accuracy))
logger.flush()
return accuracy
def train():
options = dlib.simple_object_detector_training_options()
options.add_left_right_image_flips = True
options.C = 5
options.num_threads = 4
options.be_verbose = True
options.detection_window_size = 1024
options.match_eps = 0.1
training_xml_path = "../pics/train/training-single.xml"
# training_xml_path = "/home/external/moderation-p**n-detector/oboobs.dlibxml"
dlib.train_simple_object_detector(training_xml_path, "../boobs.svm", options)
print("Training accuracy: {}".format(dlib.test_simple_object_detector(training_xml_path, "../boobs.svm")))
def create_svm(request,pk,template_name='create_svm.html'):
brand = get_object_or_404(Brands, pk=pk)
data = {}
data[ 'pk' ] = pk
if request.method == 'POST':
svm = request.POST.get('svm')
cval = request.POST.get('cval')
paths = Paths.objects.filter( brand_id = pk )
if paths.exists():
for pt in paths:
train_path = pt.train_path
train_path = os.path.relpath(train_path,settings.MEDIA_ROOT)
test_path = pt.test_path
test_path = os.path.relpath(test_path,settings.MEDIA_ROOT)
svm_path = pt.svm_path
#cmd = "python 35Hawkdetect.py /var/sites/thirdauth/static/images/companies/Stovekraft\ Private\ Limited\(mohsin\)/idea/test/ cola123.svm jpg"
print svm_path
print settings.MEDIA_ROOT+"/"+train_path+"/"
faces_folder = settings.MEDIA_ROOT+"/"+train_path+"/"
test_folder = settings.MEDIA_ROOT+"/"+test_path+"/"
print faces_folder
#dest = "/var/sites/thirdauth/static/images/companies/Stovekraft Private Limited(mohsin)/Docomo/svm"
timestr = svm+time.strftime("_%m_%d_%H_%M")+".svm"
print timestr
outputpath = str(svm)+".svm"
cval = cval
options = dlib.simple_object_detector_training_options()
options.add_left_right_image_flips = True
options.C = int(cval)
options.num_threads = 4
options.be_verbose = True
training_xml_path = os.path.join(str(faces_folder), "training.xml")
testing_xml_path = os.path.join(str(test_folder), "training.xml")
dlib.train_simple_object_detector(training_xml_path,outputpath, options)
print("")
print("Training accuracy: {}".format(
dlib.test_simple_object_detector(training_xml_path, outputpath)))
print("Testing accuracy: {}".format(
dlib.test_simple_object_detector(testing_xml_path, outputpath)))
result = "Training accuracy: {}"+format(dlib.test_simple_object_detector(training_xml_path, outputpath))+" Testing accuracy: {}"+format(dlib.test_simple_object_detector(testing_xml_path, outputpath))
os.rename(str(outputpath),timestr)
if os.path.exists(str(svm_path)+"/"+str(timestr)):
os.remove(str(svm_path)+"/"+str(timestr))
shutil.move("/var/sites/thirdauth/"+str(timestr),str(svm_path))
Svms(svm_name = str(timestr), brand_id = pk , company_id = brand.company_id ).save()
return HttpResponse(result)
else:
return render(request,template_name, data ,context_instance=RequestContext(request))
# does all the training import os import sys import glob import dlib # from skimage import io path = os.getcwd() + '/../' options = dlib.simple_object_detector_training_options() 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 = 2 options.be_verbose = True training_xml_path = os.path.join(path, 'data/mdl_detector/train.xml') testing_xml_path = os.path.join(path, 'data/mdl_detector/test.xml') # does the training dlib.train_simple_object_detector(training_xml_path, path + 'data/detector.svm', options)
def train_dlib_detector(images, epsilon=0.01, add_left_right_image_flips=False,
verbose_stdout=False, C=5, detection_window_size=6400,
num_threads=None):
r"""
Train a dlib detector with the given list of images.
This is intended to easily train a list of menpo images that have their
bounding boxes attached as landmarks. Each landmark group on the image
will have a tight bounding box extracted from it and then dlib will
train given these images.
Parameters
----------
images : `list` of `menpo.image.Image`
The set of images to learn the detector from. Must have landmarks
attached to **every** image, a bounding box will be extracted for each
landmark group.
epsilon : `float`, optional
The stopping epsilon. Smaller values make the trainer's solver more
accurate but might take longer to train.
add_left_right_image_flips : `bool`, optional
If ``True``, assume the objects are left/right symmetric and add in
left right flips of the training images. This doubles the size of the
training dataset.
verbose_stdout : `bool`, optional
If ``True``, will allow dlib to output its verbose messages. These
will only be printed to the stdout, so will **not** appear in an IPython
notebook.
C : `int`, optional
C is the usual SVM C regularization parameter. Larger values of C will
encourage the trainer to fit the data better but might lead to
overfitting.
detection_window_size : `int`, optional
The number of pixels inside the sliding window used. The default
parameter of ``6400 = 80 * 80`` window size.
num_threads : `int` > 0 or ``None``
How many threads to use for training. If ``None``, will query
multiprocessing for the number of cores.
Returns
-------
detector : `dlib.simple_object_detector`
The trained detector. To save this detector, call save on the returned
object and pass a string path.
Examples
--------
Training a simple object detector from a list of menpo images and save it
for later use:
>>> images = list(mio.import_images('./images/path'))
>>> in_memory_detector = train_dlib_detector(images, verbose_stdout=True)
>>> in_memory_detector.save('in_memory_detector.svm')
"""
rectangles = [[pointgraph_to_rect(lgroup.lms.bounding_box())
for lgroup in im.landmarks.values()]
for im in images]
image_pixels = [menpo_image_to_uint8(im) for im in images]
if num_threads is None:
import multiprocessing
num_threads = multiprocessing.cpu_count()
options = dlib.simple_object_detector_training_options()
options.epsilon = epsilon
options.add_left_right_image_flips = add_left_right_image_flips
options.be_verbose = verbose_stdout
options.C = C
options.detection_window_size = detection_window_size
options.num_threads = num_threads
return dlib.train_simple_object_detector(image_pixels, rectangles, options)
# -*- coding: utf-8 -*-
import os
import dlib
# 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
# 支持向量机的C参数，通常默认取为5.自己适当更改参数以达到最好的效果
options.C = 5
# 线程数，你电脑有4核的话就填4
options.num_threads = 4
options.be_verbose = True
# 获取路径
current_path = os.getcwd()
# train_folder = current_path + '/cats_train/'
# test_folder = current_path + '/cats_test/'
# train_xml_path = train_folder + 'cat.xml'
# test_xml_path = test_folder + 'cats.xml'
train_folder = 'C:/Users/kk/Downloads/dlib-19.15/tools/imglab/build/images/cat/'
test_folder = 'C:/Users/kk/Downloads/dlib-19.15/tools/imglab/build/images/cat/test/'
train_xml_path = train_folder + 'cat.xml'
# test_xml_path = test_folder + 'cats.xml'
print("training file path:" + train_xml_path)
# print(train_xml_path)
# print("testing file path:" + test_xml_path)
# print(test_xml_path)
def train(image_folder, append):
if append == 0:
#code to open createXML for the noob user with all the required params
cmd = 'createXML.exe -c' + image_folder + '/training.xml ' + image_folder
run(cmd, 5)
cmd = 'createXML.exe ' + image_folder + '/training.xml'
run(cmd, 50)
# <NOTE> <IN PROGRESS> include code to write new XML to the old XML and use the latter for the training
elif append == 1:
#code to open createXML for the noob user with all the required params
cmd = 'createXML.exe -c' + image_folder + '/trainingTemp.xml ' + image_folder
run(cmd, 5)
cmd = 'createXML.exe ' + image_folder + '/trainingTemp.xml'
run(cmd, 50)
dlib.hit_enter_to_continue()
# doing all the magic stuff to append the new XML to the old one
xml1 = image_folder + "/training.xml"
xml2 = image_folder + "/trainingTemp.xml"
removeUselessText(xml1)
removeUselessText(xml2)
#combineXML(xml1,xml2)
r = XMLCombiner((xml1, xml2)).combine()
with open(xml1, "r+") as f:
f.write(et.tostring(r.getroot()))
#Convert the XML to better format before saving it for the training as there may be some improper indentation
# setting option in dlib
options = dlib.simple_object_detector_training_options()
# symmetric detector
options.add_left_right_image_flips = True
# SVM C parameter.larger value will lead to overfitting
options.C = 2
# 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(image_folder, "training.xml")
#testing_xml_path = os.path.join(image_folder, "testing.xml")
# saving the detector as detector.svm with input as the xml file after doing the training
dlib.train_simple_object_detector(training_xml_path, "detector.svm",
options)
# Printing the accuracy with training data
print("\nTraining accuracy: {}".format(
dlib.test_simple_object_detector(training_xml_path, "detector.svm")))
# Doing the detection
detector = dlib.simple_object_detector("detector.svm")
# Looking at the HOG filter the machine has learned.
win_det = dlib.image_window()
win_det.set_image(detector)
def train_dlib_detector(images,
output_path,
epsilon=0.01,
add_left_right_image_flips=False,
verbose_stdout=False,
C=5,
detection_window_size=6400,
num_threads=None):
r"""
Train a dlib detector with the given list of images.
This is intended to easily train a list of menpo images that have their
bounding boxes attached as landmarks. Each landmark group on the image
will have a tight bounding box extracted from it and then dlib will
train given these images. At the moment, the output is written to file
and must be loaded back up when training is completed. No verbose
messages will be provided by default.
Parameters
----------
images : list of menpo.image.Image
The set of images to learn the detector from. Must have landmarks
attached to **every** image, a bounding box will be extracted for each
landmark group.
output_path : Path or str
The output path for dlib to save the detector to.
epsilon : float, optional
The stopping epsilon. Smaller values make the trainer's solver more
accurate but might take longer to train.
add_left_right_image_flips : bool, optional
If ``True``, assume the objects are left/right symmetric and add in
left right flips of the training images. This doubles the size of the
training dataset.
verbose_stdout : bool, optional
If ``True``, will allow dlib to output its verbose messages. These
will only be printed to the stdout, so will **not** appear in an IPython
notebook.
C : int, optional
C is the usual SVM C regularization parameter. Larger values of C will
encourage the trainer to fit the data better but might lead to
overfitting.
detection_window_size : int, optional
The number of pixels inside the sliding window used. The default
parameter of 6400 = 80 * 80 window size.
num_threads : int > 0 or None
How many threads to use for training. If ``None``, will query
multiprocessing for the number of cores.
"""
rectangles = [[
pointgraph_to_rect(lgroup.lms.bounding_box())
for lgroup in im.landmarks.values()
] for im in images]
images = [menpo_image_to_uint8(im) for im in images]
if num_threads is None:
import multiprocessing
num_threads = multiprocessing.cpu_count()
options = dlib.simple_object_detector_training_options()
options.epsilon = epsilon
options.add_left_right_image_flips = add_left_right_image_flips
options.be_verbose = verbose_stdout
options.C = C
options.detection_window_size = detection_window_size
options.num_threads = num_threads
output_path_str = str(output_path)
dlib.train_simple_object_detector(images, rectangles, output_path_str,
options)
def train_dlib_detector(images,
epsilon=0.01,
add_left_right_image_flips=False,
verbose_stdout=False,
C=5,
detection_window_size=6400,
num_threads=None):
r"""
Train a dlib detector with the given list of images.
This is intended to easily train a list of menpo images that have their
bounding boxes attached as landmarks. Each landmark group on the image
will have a tight bounding box extracted from it and then dlib will
train given these images.
Parameters
----------
images : `list` of `menpo.image.Image`
The set of images to learn the detector from. Must have landmarks
attached to **every** image, a bounding box will be extracted for each
landmark group.
epsilon : `float`, optional
The stopping epsilon. Smaller values make the trainer's solver more
accurate but might take longer to train.
add_left_right_image_flips : `bool`, optional
If ``True``, assume the objects are left/right symmetric and add in
left right flips of the training images. This doubles the size of the
training dataset.
verbose_stdout : `bool`, optional
If ``True``, will allow dlib to output its verbose messages. These
will only be printed to the stdout, so will **not** appear in an IPython
notebook.
C : `int`, optional
C is the usual SVM C regularization parameter. Larger values of C will
encourage the trainer to fit the data better but might lead to
overfitting.
detection_window_size : `int`, optional
The number of pixels inside the sliding window used. The default
parameter of ``6400 = 80 * 80`` window size.
num_threads : `int` > 0 or ``None``
How many threads to use for training. If ``None``, will query
multiprocessing for the number of cores.
Returns
-------
detector : `dlib.simple_object_detector`
The trained detector. To save this detector, call save on the returned
object and pass a string path.
Examples
--------
Training a simple object detector from a list of menpo images and save it
for later use:
>>> images = list(mio.import_images('./images/path'))
>>> in_memory_detector = train_dlib_detector(images, verbose_stdout=True)
>>> in_memory_detector.save('in_memory_detector.svm')
"""
rectangles = [[
pointgraph_to_rect(lgroup.lms.bounding_box())
for lgroup in im.landmarks.values()
] for im in images]
image_pixels = [menpo_image_to_uint8(im) for im in images]
if num_threads is None:
import multiprocessing
num_threads = multiprocessing.cpu_count()
options = dlib.simple_object_detector_training_options()
options.epsilon = epsilon
options.add_left_right_image_flips = add_left_right_image_flips
options.be_verbose = verbose_stdout
options.C = C
options.detection_window_size = detection_window_size
options.num_threads = num_threads
return dlib.train_simple_object_detector(image_pixels, rectangles, options)
