def test_image_to_uint8_channels_at_front():
takeo_copy = takeo.copy()
np_im = menpo_image_to_uint8(takeo_copy, channels_at_back=False)
shi = takeo_copy.pixels.shape
shnp = np_im.shape
assert np_im.dtype == np.uint8
assert (shi[0] == shnp[0] and shi[1] == shnp[1] and shi[2] == shnp[2])
def test_image_to_uint8_channels_at_front():
takeo_copy = takeo.copy()
np_im = menpo_image_to_uint8(takeo_copy, channels_at_back=False)
shi = takeo_copy.pixels.shape
shnp = np_im.shape
assert np_im.dtype == np.uint8
assert (shi[0] == shnp[0] and shi[1] == shnp[1] and shi[2] == shnp[2])
def test_image_to_uint8():
takeo_copy = takeo.copy()
np_im = menpo_image_to_uint8(takeo_copy)
shi = takeo_copy.pixels.shape
shnp = np_im.shape
assert np_im.dtype == np.uint8
assert (shi[0] == shnp[2] and shi[1] == shnp[0] and shi[2] == shnp[1])
def test_image_to_uint8():
takeo_copy = takeo.copy()
np_im = menpo_image_to_uint8(takeo_copy)
shi = takeo_copy.pixels.shape
shnp = np_im.shape
assert np_im.dtype == np.uint8
assert (shi[0] == shnp[2] and shi[1] == shnp[0] and shi[2] == shnp[1])
def test_image_to_uint8_greyscale():
takeo_copy = takeo.as_greyscale()
np_im = menpo_image_to_uint8(takeo_copy)
shi = takeo_copy.pixels.shape
shnp = np_im.shape
assert np_im.ndim == 2
assert np_im.dtype == np.uint8
assert (shi[1] == shnp[0] and shi[2] == shnp[1])
def test_image_to_uint8_greyscale():
takeo_copy = takeo.as_greyscale()
np_im = menpo_image_to_uint8(takeo_copy)
shi = takeo_copy.pixels.shape
shnp = np_im.shape
assert np_im.ndim == 2
assert np_im.dtype == np.uint8
assert (shi[1] == shnp[0] and shi[2] == shnp[1])
def train_ffld2_detector(positive_images, negative_images, n_components=3,
pad_x=6, pad_y=6, interval=5, n_relabel=8,
n_datamine=10, max_negatives=24000, C=0.002, J=2.0,
overlap=0.5):
r"""
Train a DPM using the FFLD2 framework. This is a fairly slow process to
expect to wait for a while. FFLD2 prints out information at each iteration
but this will not appear in an IPython notebook, so it is best to run
this kind of training from the command line.
This method requires an explicit set of negative images to learn the
classifier with. The non person images from Pascal VOC 2007 are a good
example of negative images to train with.
Parameters
----------
positive_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.
negative_images : `list` of `menpo.image.Image`
The set of images to learn the negative samples of the detector with.
**No** landmarks need to be attached.
n_components : `int`
Number of mixture components (without symmetry).
pad_x : `int`
Amount of zero padding in HOG cells (x-direction).
pad_y : `int`
Amount of zero padding in HOG cells (y-direction).
interval : `int`
Number of levels per octave in the HOG pyramid.
n_relabel : `int`
Maximum number of training iterations.
n_datamine : `int`
Maximum number of data-mining iterations within each training iteration.
max_negatives : `int`
Maximum number of negative images to consider, can be useful for
reducing training time.
C : `double`
SVM regularization constant.
J : `double`
SVM positive regularization constant boost.
overlap : `double`
Minimum overlap in in latent positive search and non-maxima suppression.
Returns
-------
model : `FFLDMixture`
The newly trained model.
"""
positive_image_arrays = []
negative_image_arrays = []
positive_bbox_arrays = []
for image in positive_images:
image_pixels = menpo_image_to_uint8(image)
image_pixels = ensure_channel_axis(image_pixels)
positive_image_arrays.append(image_pixels)
im_bounding_boxes = []
for lmark in image.landmarks.values():
bb = lmark.lms.bounding_box()
height, width = bb.range()
min_p, max_p = bb.bounds()
im_bounding_boxes.append(np.array([min_p[1], min_p[0],
width, height]))
positive_bbox_arrays.append(im_bounding_boxes)
for image in negative_images:
image_pixels = menpo_image_to_uint8(image)
image_pixels = ensure_channel_axis(image_pixels)
negative_image_arrays.append(image_pixels)
return train_model(positive_image_arrays, positive_bbox_arrays,
negative_image_arrays, n_components=n_components,
pad_x=pad_x, pad_y=pad_y, interval=interval,
n_relabel=n_relabel, n_datamine=n_datamine,
max_negatives=max_negatives, C=C, J=J, overlap=overlap)
def train_ffld2_detector(positive_images,
negative_images,
n_components=3,
pad_x=6,
pad_y=6,
interval=5,
n_relabel=8,
n_datamine=10,
max_negatives=24000,
C=0.002,
J=2.0,
overlap=0.5):
r"""
Train a DPM using the FFLD2 framework. This is a fairly slow process to
expect to wait for a while. FFLD2 prints out information at each iteration
but this will not appear in an IPython notebook, so it is best to run
this kind of training from the command line.
This method requires an explicit set of negative images to learn the
classifier with. The non person images from Pascal VOC 2007 are a good
example of negative images to train with.
Parameters
----------
positive_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.
negative_images : `list` of `menpo.image.Image`
The set of images to learn the negative samples of the detector with.
**No** landmarks need to be attached.
n_components : `int`
Number of mixture components (without symmetry).
pad_x : `int`
Amount of zero padding in HOG cells (x-direction).
pad_y : `int`
Amount of zero padding in HOG cells (y-direction).
interval : `int`
Number of levels per octave in the HOG pyramid.
n_relabel : `int`
Maximum number of training iterations.
n_datamine : `int`
Maximum number of data-mining iterations within each training iteration.
max_negatives : `int`
Maximum number of negative images to consider, can be useful for
reducing training time.
C : `double`
SVM regularization constant.
J : `double`
SVM positive regularization constant boost.
overlap : `double`
Minimum overlap in in latent positive search and non-maxima suppression.
Returns
-------
model : `FFLDMixture`
The newly trained model.
"""
positive_image_arrays = []
negative_image_arrays = []
positive_bbox_arrays = []
for image in positive_images:
image_pixels = menpo_image_to_uint8(image)
image_pixels = ensure_channel_axis(image_pixels)
positive_image_arrays.append(image_pixels)
im_bounding_boxes = []
for lmark in image.landmarks.values():
bb = lmark.bounding_box()
height, width = bb.range()
min_p, max_p = bb.bounds()
im_bounding_boxes.append(
np.array([min_p[1], min_p[0], width, height]))
positive_bbox_arrays.append(im_bounding_boxes)
for image in negative_images:
image_pixels = menpo_image_to_uint8(image)
image_pixels = ensure_channel_axis(image_pixels)
negative_image_arrays.append(image_pixels)
return train_model(positive_image_arrays,
positive_bbox_arrays,
negative_image_arrays,
n_components=n_components,
pad_x=pad_x,
pad_y=pad_y,
interval=interval,
n_relabel=n_relabel,
n_datamine=n_datamine,
max_negatives=max_negatives,
C=C,
J=J,
overlap=overlap)
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)
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)
