Commit 1d78c1bb authored by Amir MOHAMMADI's avatar Amir MOHAMMADI

bob.learn.mlp is deprecated

parent 0c41d81c
Pipeline #50739 passed with stage
in 21 minutes and 51 seconds
from .crop import Cropper, FixedCrop, NoCrop
from .mask import Padder, Masker, FixedMask, NoMask, AnnotatedRoIMask
from .mask import KonoMask, LeeMask, TomesLeeMask, WatershedMask
from .mask import KonoMask, LeeMask, TomesLeeMask
from .normalize import Normalizer, NoNormalization, HuangNormalization
from .filters import Filter, NoFilter, HistogramEqualization
from .preprocessor import Preprocessor
......@@ -31,7 +31,6 @@ __appropriate__(
......@@ -477,193 +477,3 @@ class TomesLeeMask(Masker):
w = self.padder.padding_width
return finger_mask[w:-w,w:-w]
class WatershedMask(Masker):
"""Estimates the finger region given an input NIR image using Watershedding
This method uses the `Watershedding Morphological Algorithm
<>` for determining
the finger mask given an input image.
The masker works first by determining image edges using a simple 2-D Sobel
filter. The next step is to determine markers in the image for both the
finger region and background. Markers are set on the image by using a
pre-trained feed-forward neural network model (multi-layer perceptron or MLP)
learned from existing annotations. The model is trained in a separate
program and operates on 3x3 regions around the pixel to be predicted for
finger/background. The ``(y,x)`` location also is provided as input to the
classifier. The feature vector is then composed of 9 pixel values plus the
``y`` and ``x`` (normalized) coordinates of the pixel. The network then
provides a prediction that depends on these input parameters. The closer the
output is to ``1.0``, the more likely it is from within the finger region.
Values output by the network are thresholded in order to remove uncertain
markers. The ``threshold`` parameter is configurable.
A series of morphological opening operations is used to, given the neural net
markers, remove noise before watershedding the edges from the Sobel'ed
original image.
model (str): Path to the model file to be used for generating
finger/background markers. This model should be pre-trained using a
separate program.
foreground_threshold (float): Threshold given a logistic regression output
(interval :math:`[0, 1]`) for which we consider finger markers provided
by the network. The higher the value, the more selective the algorithm
will be and the less (foreground) markers will be used from the network
selection. This value should be a floating point number in the open-set
interval :math:`(0.0, 1.0)`. If ``background_threshold`` is not set,
values for background selection will be set to :math:`1.0-T`, where ``T``
represents this threshold.
background_threshold (float): Threshold given a logistic regression output
(interval :math:`[0, 1]`) for which we consider finger markers provided
by the network. The smaller the value, the more selective the algorithm
will be and the less (background) markers will be used from the network
selection. This value should be a floating point number in the open-set
interval :math:`(0.0, 1.0)`. If ``foreground_threshold`` is not set,
values for foreground selection will be set to :math:`1.0-T`, where ``T``
represents this threshold.
def __init__(self, model, foreground_threshold, background_threshold):
import bob.learn.mlp
import bob.learn.activation
self.labeller = bob.learn.mlp.Machine((11,10,1))
h5f =
self.labeller.output_activation = bob.learn.activation.Logistic()
del h5f
# adjust threshold from background and foreground
if foreground_threshold is None and background_threshold is not None:
foreground_threshold = 1 - background_threshold
if background_threshold is None and foreground_threshold is not None:
background_threshold = 1 - foreground_threshold
if foreground_threshold is None and background_threshold is None:
foreground_threshold = 0.5
background_threshold = 0.5
self.foreground_threshold = foreground_threshold
self.background_threshold = background_threshold
class _filterfun(object):
'''Callable for filtering the input image with marker predictions'''
def __init__(self, image, labeller):
self.labeller = labeller
self.features = numpy.zeros(self.labeller.shape[0], dtype='float64')
self.output = numpy.zeros(self.labeller.shape[-1], dtype='float64')
# builds indexes before hand, based on image dimensions
idx = numpy.mgrid[:image.shape[0], :image.shape[1]]
self.indexes = numpy.array([idx[0].flatten(), idx[1].flatten()],
self.indexes[0,:] /= image.shape[0]
self.indexes[1,:] /= image.shape[1]
self.current = 0
def __call__(self, arr):
self.features[:9] = arr.astype('float64')/255
self.features[-2:] = self.indexes[:,self.current]
self.current += 1
return self.labeller(self.features, self.output)
def run(self, image):
'''Fully preprocesses the input image and returns intermediate results
image (numpy.ndarray): A 2D numpy array of type ``uint8`` with the
input image
numpy.ndarray: A 2D numpy array of type ``uint8`` with the markers for
foreground and background, selected by the neural network model
numpy.ndarray: A 2D numpy array of type ``float64`` with the edges used
to define the borders of the watermasking process
numpy.ndarray: A 2D numpy array of type boolean with the caculated
mask. ``True`` values correspond to regions where the finger is
# applies the pre-trained neural network model to get predictions about
# finger/background regions
function = WatershedMask._filterfun(image, self.labeller)
predictions = numpy.zeros(image.shape, 'float64')
scipy.ndimage.filters.generic_filter(image, function,
size=3, mode='nearest', output=predictions)
selector = skimage.morphology.disk(radius=5)
# applies a morphological "opening" operation
# ( to remove outliers
markers_bg = numpy.where(predictions<self.background_threshold, 1, 0)
markers_bg = skimage.morphology.opening(markers_bg, selem=selector)
markers_fg = numpy.where(predictions>=self.foreground_threshold, 255, 0)
markers_fg = skimage.morphology.opening(markers_fg, selem=selector)
# avoids markers on finger borders
selector = skimage.morphology.disk(radius=2)
markers_fg = skimage.morphology.erosion(markers_fg, selem=selector)
# the final markers are a combination of foreground and background markers
markers = markers_fg | markers_bg
# this will determine the natural boundaries in the image where the
# flooding will be limited - dialation is applied on the output of the
# Sobel filter to well mark the finger boundaries
edges = skimage.filters.sobel(image)
edges = skimage.morphology.dilation(edges, selem=selector)
# applies watersheding to get a final estimate of the finger mask
segmentation = skimage.morphology.watershed(edges, markers)
# removes small perturbations and makes the finger region more uniform
segmentation[segmentation==1] = 0
mask = skimage.morphology.binary_opening(segmentation.astype('bool'),
return markers, edges, mask
def __call__(self, image):
'''Inputs an image, returns a mask (numpy boolean array)
image (numpy.ndarray): A 2D numpy array of type ``uint8`` with the
input image
numpy.ndarray: A 2D numpy array of type boolean with the caculated
mask. ``True`` values correspond to regions where the finger is
markers, edges, mask =
return mask
This diff is collapsed.
#!/usr/bin/env python
# vim: set fileencoding=utf-8 :
# Wed 4 Oct 11:23:52 2017 CEST
"""Preprocesses a fingervein image with a watershed/neural-net seeded mask
Usage: %(prog)s [-v...] [-s <path>] [-f <float>] [-b <float>] [--scan]
<model> <database> [<stem>...]
%(prog)s --help
%(prog)s --version
<model> Path to model to use for find watershed markers
<database> Name of the database to use for creating the model (options are:
"fv3d" or "verafinger")
<stem> Name of the object on the database to display, without the root
or the extension. If none provided, run for all possible stems on
the database
-h, --help Shows this help message and exits
-V, --version Prints the version and exits
-v, --verbose Increases the output verbosity level
-f, --fg-threshold=<float> Foreground threshold value. Should be set to a
number that is between 0.5 and 1.0. The higher,
the less markers for the foreground watershed
process will be produced. [default: 0.7]
-b, --bg-threshold=<float> Background threshold value. Should be set to a
number that is between 0.0 and 0.5. The smaller,
the less markers for the foreground watershed
process will be produced. [default: 0.3]
-S, --scan If set, ignores settings for the threshold and
scans the whole range of threshold printing the
Jaccard, M1 and M2 merith figures
-s <path>, --save=<path> If set, saves individual image into files instead
of displaying the result of processing. Pass the
name of directory that will be created and
suffixed with the paths of original images.
Visualize the preprocessing toolchain over a single image
$ %(prog)s model.hdf5 verafinger sample-stem
Save the results of the preprocessing to several files. In this case, the
program runs non-interactively:
$ %(prog)s -s graphics model.hdf5 verafinger sample-stem
Scans the set of possible thresholds printing Jaccard, M1 and M2 indexes:
$ %(prog)s --scan model.hdf5 verafinger sample-stem
import os
import sys
import time
import numpy
import schema
import docopt
import bob.core
logger = bob.core.log.setup("")
import matplotlib.pyplot as plt
def validate(args):
'''Validates command-line arguments, returns parsed values
This function uses :py:mod:`schema` for validating :py:mod:`docopt`
arguments. Logging level is not checked by this procedure (actually, it is
ignored) and must be previously setup as some of the elements here may use
logging for outputing information.
args (dict): Dictionary of arguments as defined by the help message and
returned by :py:mod:`docopt`
dict: Validate dictionary with the same keys as the input and with values
possibly transformed by the validation procedure
schema.SchemaError: in case one of the checked options does not validate.
valid_databases = ('fv3d', 'verafinger')
sch = schema.Schema({
'<model>': schema.And(os.path.exists,
error='<model> should point to an existing path'),
'<database>': schema.And(lambda n: n in valid_databases,
error='<database> must be one of %s' % ', '.join(valid_databases)),
'--fg-threshold': schema.And(
schema.Use(float), lambda n: 0.5 < n < 1.0,
error='--fg-threshold should be a float between 0.5 and 1.0',
'--bg-threshold': schema.And(
schema.Use(float), lambda n: 0.0 < n < 0.5,
error='--bg-threshold should be a float between 0.0 and 0.5',
str: object, #ignores strings we don't care about
}, ignore_extra_keys=True)
return sch.validate(args)
def save_figures(title, image, markers, edges, mask):
'''Saves individual images on a directory
dirname = os.path.dirname(title)
if not os.path.exists(dirname): os.makedirs(dirname), os.path.join(title, 'original.png'))
_ = markers.copy().astype('uint8')
_[_==1] = 128, os.path.join(title, 'markers.png'))*edges).astype('uint8'), os.path.join(title,'edges.png'))'uint8')*255, os.path.join(title, 'mask.png'))
from ..preprocessor.utils import draw_mask_over_image
masked_image = draw_mask_over_image(image, mask), 'masked.png'))
def make_figure(image, markers, edges, mask):
'''Returns a matplotlib figure with the detailed processing result'''
plt.clf() #completely clears the current figure
figure = plt.gcf()
_ = markers.copy().astype('uint8')
_[_==1] = 128
plt.imshow(_, cmap='gray')
_ = numpy.dstack([
(_ | (255*edges).astype('uint8')),
plt.imshow(mask.astype('uint8')*255, cmap='gray')
plt.imshow(image, cmap='gray')
red_mask = numpy.dstack([
plt.imshow(red_mask, alpha=0.15)
plt.title('Image (masked)')
return figure
def process_one(args, image, path):
'''Processes a single image'''
from import WatershedMask, AnnotatedRoIMask
# loads the processor once - avoids re-reading weights from the disk
processor = WatershedMask(
annotator = AnnotatedRoIMask()
from import \
jaccard_index, intersect_ratio, intersect_ratio_of_complement
start = time.time()
markers, edges, mask =
total_time = time.time() - start
# error
annotated_mask = annotator(image)
ji = jaccard_index(annotated_mask, mask)
m1 = intersect_ratio(annotated_mask, mask)
m2 = intersect_ratio_of_complement(annotated_mask, mask)
logger.debug('%s, %.2f, %.2f, %.2f, %g, %g, %g', path, total_time,
args['--fg-threshold'], args['--bg-threshold'], ji, m1, m2)
if not args['--scan']:
if args['--save']:
dest = os.path.join(args['--save'], path)
save_figures(dest, image, markers, edges, mask)
fig = make_figure(image, markers, edges, mask)
fig.suptitle('%s @ %s - JI=%.4f, M1=%.4f, M2=%.4f\n' \
'($\\tau_{FG}$ = %.2f - $\\tau_{BG}$ = %.2f)' % \
(path, args['<database>'], ji, m1, m2, args['--fg-threshold'],
args['--bg-threshold']), fontsize=12)
print('Close the figure to continue...')
return (path, total_time, args['--fg-threshold'], args['--bg-threshold'],
ji, m1, m2)
def eval_best_thresholds(results):
'''Evaluates the best thresholds taking into consideration various indexes'''
m1 = numpy.array([k[-2] for k in results])
m2 = numpy.array([k[-1] for k in results])
index = m1/m2
return index.argmax()
def main(user_input=None):
if user_input is not None:
argv = user_input
argv = sys.argv[1:]
import pkg_resources
completions = dict(
args = docopt.docopt(
__doc__ % completions,
from .validate import setup_logger
logger = setup_logger('', args['--verbose'])
args = validate(args)
except schema.SchemaError as e:
if args['<database>'] == 'fv3d':
from import database as db
elif args['<database>'] == 'verafinger':
from import database as db
database_replacement = "%s/.bob_bio_databases.txt" % os.environ["HOME"]
all_files = db.objects()
# if a specific <stem> was not provided, run for all possible stems
if not args['<stem>']:
args['<stem>'] = [k.path for k in all_files]
# Loads the image, the mask and save it to a PNG file
for stem in args['<stem>']:
f = [k for k in all_files if k.path == stem]
if len(f) == 0:
raise RuntimeError('File with stem "%s" does not exist on "%s"' % \
stem, args['<database>'])
f = f[0]
image = f.load(db.original_directory, db.original_extension)
if args['--scan']:
results = []
logger.debug('stem, time, fg_thres, bg_thres, jaccard, m1, m2')
for fg_threshold in numpy.arange(0.6, 1.0, step=0.1):
for bg_threshold in numpy.arange(0.1, 0.5, step=0.1):
args['--fg-threshold'] = fg_threshold
args['--bg-threshold'] = bg_threshold
results.append(process_one(args, image, f.path))
best_thresholds = eval_best_thresholds(results)'%s: FG = %.2f | BG = %.2f | M1/M2 = %.2f', f.path,
results[best_thresholds][2], results[best_thresholds][3],
process_one(args, image, f.path)
......@@ -10,8 +10,6 @@ build:
- =
- =
- =
- =
- =
number: {{ environ.get('BOB_BUILD_NUMBER', 0) }}
- {{ pin_subpackage(name) }}
......@@ -41,8 +39,6 @@ requirements:
- bob.ip.color
- bob.learn.linear
- bob.learn.activation
- bob.learn.mlp
- python
......@@ -62,8 +58,6 @@ test:
- --help
- --help
- --help
- --help
- --help
- nosetests --with-coverage --cover-package={{ name }} -sv {{ name }}
- sphinx-build -aEW {{ project_dir }}/doc {{ project_dir }}/sphinx
- sphinx-build -aEb doctest {{ project_dir }}/doc sphinx
......@@ -17,7 +17,7 @@ $ bob bio pipelines vanilla-biometrics [DATABASE_NAME] [BASELINE]
Both, `[DATABASE_NAME]` and `[BASELINE]` can be either python resources or
python files.
Please, refer to :ref:` <>` for more information.
Please, refer to :ref:` <>` for more information.
Repeated Line-Tracking with Miura Matching
......@@ -37,8 +37,8 @@ protocol, do the following:
.. tip::
If you have more processing cores on your local machine and don't want to
submit your job for SGE execution, you can run it in parallel by adding the options ``-l local-parallel``.
submit your job for SGE execution, you can run it in parallel by adding the options ``-l local-parallel``.
.. code-block:: sh
$ bob bio pipelines vanilla-biometrics verafinger rlt -vv -c -l local-parallel
......@@ -261,49 +261,6 @@ This package contains other resources that can be used to evaluate different
bits of the vein processing toolchain.
Training the Watershed Finger region detector
The correct detection of the finger boundaries is an important step of many
algorithms for the recognition of finger veins. It allows to compensate for
eventual rotation and scaling issues one might find when comparing models and
probes. In this package, we propose a novel finger boundary detector based on
the `Watershedding Morphological Algorithm
<>`. Watershedding
works in three steps:
1. Determine markers on the original image indicating the types of areas one
would like to detect (e.g. "finger" or "background")
2. Determine a 2D (gray-scale) surface representing the original image in which
darker spots (representing valleys) are more likely to be filled by
surrounding markers. This is normally achieved by filtering the image with a
high-pass filter like Sobel or using an edge detector such as Canny.
3. Run the watershed algorithm
In order to determine markers for step 1, we train a neural network which
outputs the likelihood of a point being part of a finger, given its coordinates
and values of surrounding pixels.
When used to run an experiment,
:py:class:`` requires you provide a
*pre-trained* neural network model that presets the markers before
watershedding takes place. In order to create one, you can run the program
.. code-block:: sh
$ --hidden=20 --samples=500 fv3d central dev
You input, as arguments to this application, the database, protocol and subset
name you wish to use for training the network. The data is loaded observing a
total maximum number of samples from the dataset (passed with ``--samples=N``),
the network is trained and recorded into an HDF5 file (by default, the file is
called ``model.hdf5``, but the name can be changed with the option
``--model=``). Once you have a model, you can use the preprocessor mask by
constructing an object and attaching it to the
:py:class:`` entry on your configuration.
Region of Interest Goodness of Fit
......@@ -21,5 +21,4 @@
.. _mailing list:
.. _jaccard index:
.. _watershed:
.. _gridtk:
......@@ -70,8 +70,6 @@ setup(
" =",
" =",
" =",
" =",
" =",
Markdown is supported
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment