diff --git a/bob/pad/face/algorithm/VideoCascadeSvmPadAlgorithm.py b/bob/pad/face/algorithm/VideoCascadeSvmPadAlgorithm.py
index 2f04d931bdf935016dce6da21d9781f3c9d49d33..c5690a61a2488918f2c806fd4a746f0de6dd6f0a 100644
--- a/bob/pad/face/algorithm/VideoCascadeSvmPadAlgorithm.py
+++ b/bob/pad/face/algorithm/VideoCascadeSvmPadAlgorithm.py
@@ -994,7 +994,16 @@ class VideoCascadeSvmPadAlgorithm(Algorithm):
all_scores_array = np.stack(all_scores, axis = 1).astype(np.float)
# 4. Combine the scores:
- scores =self.combine_scores_of_svm_cascade(all_scores_array, self.pos_scores_slope)
+
+ one_class_flag = (svm_machine.machine_type == 'ONE_CLASS') # True if one-class SVM is used
+
+ if not(one_class_flag):
+
+ scores = np.mean(all_scores_array, axis = 1) # compute mean for two-class SVM
+
+ else: # one class SVM case
+
+ scores = self.combine_scores_of_svm_cascade(all_scores_array, self.pos_scores_slope)
return scores
diff --git a/bob/pad/face/algorithm/VideoGmmPadAlgorithm.py b/bob/pad/face/algorithm/VideoGmmPadAlgorithm.py
new file mode 100644
index 0000000000000000000000000000000000000000..366e3fd01882c859247d16c23b9989538155dd74
--- /dev/null
+++ b/bob/pad/face/algorithm/VideoGmmPadAlgorithm.py
@@ -0,0 +1,476 @@
+#!/usr/bin/env python2
+# -*- coding: utf-8 -*-
+"""
+Created on Mon Aug 28 16:47:47 2017
+
+@author: Olegs Nikisins
+"""
+
+#==============================================================================
+# Import what is needed here:
+
+from bob.pad.base.algorithm import Algorithm
+
+from bob.bio.video.utils import FrameContainer
+
+import numpy as np
+
+import bob.io.base
+
+from sklearn import mixture
+
+
+#==============================================================================
+# Main body :
+
+class VideoGmmPadAlgorithm(Algorithm):
+ """
+ This class is designed to train a GMM based PAD system. The GMM is trained
+ using data of one class (real class) only. The procedure is the following:
+
+ 1. First, the training data is mean-std normalized using mean and std of the
+ real class only.
+
+ 2. Second, the GMM with ``n_components`` Gaussians is trained using samples
+ of the real class.
+
+ 3. The input features are next classified using pre-trained GMM machine.
+
+ **Parameters:**
+
+ ``n_components`` : :py:class:`int`
+ Number of Gaussians in the GMM. Default: 1 .
+
+ ``random_state`` : :py:class:`int`
+ A seed for the random number generator used in the initialization of
+ the GMM. Default: 7 .
+
+ ``frame_level_scores_flag`` : :py:class:`bool`
+ Return scores for each frame individually if True. Otherwise, return a
+ single score per video. Default: False.
+ """
+
+ def __init__(self,
+ n_components = 1,
+ random_state = 7,
+ frame_level_scores_flag = False):
+
+
+ Algorithm.__init__(self,
+ n_components = n_components,
+ random_state = random_state,
+ frame_level_scores_flag = frame_level_scores_flag,
+ performs_projection=True,
+ requires_projector_training=True)
+
+ self.n_components = n_components
+
+ self.random_state = random_state
+
+ self.frame_level_scores_flag = frame_level_scores_flag
+
+ self.machine = None # this argument will be updated with pretrained GMM machine
+
+ self.features_mean = None # this argument will be updated with features mean
+
+ self.features_std = None # this argument will be updated with features std
+
+ # names of the arguments of the pretrained GMM machine to be saved/loaded to/from HDF5 file:
+ self.gmm_param_keys = ["covariance_type", "covariances_", "lower_bound_", "means_", "n_components", "weights_", "converged_", "precisions_", "precisions_cholesky_" ]
+
+
+ #==========================================================================
+ def convert_frame_cont_to_array(self, frame_container):
+ """
+ This function converts a single Frame Container into an array of features.
+ The rows are samples, the columns are features.
+
+ **Parameters:**
+
+ ``frame_container`` : object
+ A Frame Container conteining the features of an individual,
+ see ``bob.bio.video.utils.FrameContainer``.
+
+ **Returns:**
+
+ ``features_array`` : 2D :py:class:`numpy.ndarray`
+ An array containing features for all frames.
+ The rows are samples, the columns are features.
+ """
+
+ feature_vectors = []
+
+ frame_dictionary = {}
+
+ for frame in frame_container:
+
+ frame_dictionary[frame[0]] = frame[1]
+
+ for idx, _ in enumerate(frame_container):
+
+ # Frames are stored in a mixed order, therefore we get them using incrementing frame index:
+ feature_vectors.append(frame_dictionary[str(idx)])
+
+ features_array = np.vstack(feature_vectors)
+
+ return features_array
+
+
+ #==========================================================================
+ def convert_list_of_frame_cont_to_array(self, frame_containers):
+ """
+ This function converts a list of Frame containers into an array of features.
+ Features from different frame containers (individuals) are concatenated into the
+ same list. This list is then converted to an array. The rows are samples,
+ the columns are features.
+
+ **Parameters:**
+
+ ``frame_containers`` : [FrameContainer]
+ A list of Frame Containers, , see ``bob.bio.video.utils.FrameContainer``.
+ Each frame Container contains feature vectors for the particular individual/person.
+
+ **Returns:**
+
+ ``features_array`` : 2D :py:class:`numpy.ndarray`
+ An array containing features for all frames of all individuals.
+ """
+
+ feature_vectors = []
+
+ for frame_container in frame_containers:
+
+ video_features_array = self.convert_frame_cont_to_array(frame_container)
+
+ feature_vectors.append( video_features_array )
+
+ features_array = np.vstack(feature_vectors)
+
+ return features_array
+
+
+ #==========================================================================
+ def mean_std_normalize(self, features, features_mean= None, features_std = None):
+ """
+ The features in the input 2D array are mean-std normalized.
+ The rows are samples, the columns are features. If ``features_mean``
+ and ``features_std`` are provided, then these vectors will be used for
+ normalization. Otherwise, the mean and std of the features is
+ computed on the fly.
+
+ **Parameters:**
+
+ ``features`` : 2D :py:class:`numpy.ndarray`
+ Array of features to be normalized.
+
+ ``features_mean`` : 1D :py:class:`numpy.ndarray`
+ Mean of the features. Default: None.
+
+ ``features_std`` : 2D :py:class:`numpy.ndarray`
+ Standart deviation of the features. Default: None.
+
+ **Returns:**
+
+ ``features_norm`` : 2D :py:class:`numpy.ndarray`
+ Normalized array of features.
+
+ ``features_mean`` : 1D :py:class:`numpy.ndarray`
+ Mean of the features.
+
+ ``features_std`` : 1D :py:class:`numpy.ndarray`
+ Standart deviation of the features.
+ """
+
+ features = np.copy(features)
+
+ # Compute mean and std if not given:
+ if features_mean is None:
+
+ features_mean = np.mean(features, axis=0)
+
+ features_std = np.std(features, axis=0)
+
+ row_norm_list = []
+
+ for row in features: # row is a sample
+
+ row_norm = (row - features_mean) / features_std
+
+ row_norm_list.append(row_norm)
+
+ features_norm = np.vstack(row_norm_list)
+
+ return features_norm, features_mean, features_std
+
+
+ #==========================================================================
+ def train_gmm(self, real, n_components, random_state):
+ """
+ Train GMM classifier given real class. Prior to the training the data is
+ mean-std normalized.
+
+ **Parameters:**
+
+ ``real`` : 2D :py:class:`numpy.ndarray`
+ Training features for the real class.
+
+ ``n_components`` : :py:class:`int`
+ Number of Gaussians in the GMM. Default: 1 .
+
+ ``random_state`` : :py:class:`int`
+ A seed for the random number generator used in the initialization of
+ the GMM. Default: 7 .
+
+ **Returns:**
+
+ ``machine`` : object
+ A trained GMM machine.
+
+ ``features_mean`` : 1D :py:class:`numpy.ndarray`
+ Mean of the features.
+
+ ``features_std`` : 1D :py:class:`numpy.ndarray`
+ Standart deviation of the features.
+ """
+
+ features_norm, features_mean, features_std = self.mean_std_normalize(real)
+ # real is now mean-std normalized
+
+ machine = mixture.GaussianMixture(n_components = n_components,
+ random_state = random_state,
+ covariance_type = 'full')
+
+ machine.fit( features_norm )
+
+ return machine, features_mean, features_std
+
+
+ #==========================================================================
+ def save_gmm_machine_and_mean_std(self, projector_file, machine, features_mean, features_std):
+ """
+ Saves the GMM machine, features mean and std to the hdf5 file.
+ The absolute name of the file is specified in ``projector_file`` string.
+
+ **Parameters:**
+
+ ``projector_file`` : :py:class:`str`
+ Absolute name of the file to save the data to, as returned by
+ ``bob.pad.base`` framework.
+
+ ``machine`` : object
+ The GMM machine to be saved. As returned by sklearn.linear_model
+ module.
+
+ ``features_mean`` : 1D :py:class:`numpy.ndarray`
+ Mean of the features.
+
+ ``features_std`` : 1D :py:class:`numpy.ndarray`
+ Standart deviation of the features.
+ """
+
+ f = bob.io.base.HDF5File(projector_file, 'w') # open hdf5 file to save to
+
+ for key in self.gmm_param_keys:
+
+ data = getattr( machine, key )
+
+ f.set( key, data )
+
+ f.set( "features_mean", features_mean )
+
+ f.set( "features_std", features_std )
+
+ del f
+
+
+ #==========================================================================
+ def train_projector(self, training_features, projector_file):
+ """
+ Train GMM for feature projection and save it to file.
+ The ``requires_projector_training = True`` flag must be set to True
+ to enable this function.
+
+ **Parameters:**
+
+ ``training_features`` : [[FrameContainer], [FrameContainer]]
+ A list containing two elements: [0] - a list of Frame Containers with
+ feature vectors for the real class; [1] - a list of Frame Containers with
+ feature vectors for the attack class.
+
+ ``projector_file`` : :py:class:`str`
+ The file to save the trained projector to, as returned by the
+ ``bob.pad.base`` framework.
+ """
+
+ # training_features[0] - training features for the REAL class.
+ real = self.convert_list_of_frame_cont_to_array(training_features[0]) # output is array
+
+ # training_features[1] - training features for the ATTACK class.
+# attack = self.convert_list_of_frame_cont_to_array(training_features[1]) # output is array
+
+ # Train the GMM machine and get normalizers:
+ machine, features_mean, features_std = self.train_gmm(real = real,
+ n_components = self.n_components,
+ random_state = self.random_state)
+
+ # Save the GNN machine and normalizers:
+ self.save_gmm_machine_and_mean_std(projector_file, machine, features_mean, features_std)
+
+
+ #==========================================================================
+ def load_gmm_machine_and_mean_std(self, projector_file):
+ """
+ Loads the machine, features mean and std from the hdf5 file.
+ The absolute name of the file is specified in ``projector_file`` string.
+
+ **Parameters:**
+
+ ``projector_file`` : :py:class:`str`
+ Absolute name of the file to load the trained projector from, as
+ returned by ``bob.pad.base`` framework.
+
+ **Returns:**
+
+ ``machine`` : object
+ The loaded GMM machine. As returned by sklearn.mixture module.
+
+ ``features_mean`` : 1D :py:class:`numpy.ndarray`
+ Mean of the features.
+
+ ``features_std`` : 1D :py:class:`numpy.ndarray`
+ Standart deviation of the features.
+ """
+
+ f = bob.io.base.HDF5File(projector_file, 'r') # file to read the machine from
+
+ # initialize the machine:
+ machine = mixture.GaussianMixture()
+
+ # set the params of the machine:
+ for key in self.gmm_param_keys:
+
+ data = f.read(key)
+
+ setattr(machine, key, data)
+
+ features_mean = f.read("features_mean")
+
+ features_std = f.read("features_std")
+
+ del f
+
+ return machine, features_mean, features_std
+
+
+ #==========================================================================
+ def load_projector(self, projector_file):
+ """
+ Loads the machine, features mean and std from the hdf5 file.
+ The absolute name of the file is specified in ``projector_file`` string.
+
+ This function sets the arguments ``self.machine``, ``self.features_mean``
+ and ``self.features_std`` of this class with loaded machines.
+
+ The function must be capable of reading the data saved with the
+ :py:meth:`train_projector` method of this class.
+
+ Please register `performs_projection = True` in the constructor to
+ enable this function.
+
+ **Parameters:**
+
+ ``projector_file`` : :py:class:`str`
+ The file to read the projector from, as returned by the
+ ``bob.pad.base`` framework. In this class the names of the files to
+ read the projectors from are modified, see ``load_machine`` and
+ ``load_cascade_of_machines`` methods of this class for more details.
+ """
+
+ machine, features_mean, features_std = self.load_gmm_machine_and_mean_std(projector_file)
+
+ self.machine = machine
+
+ self.features_mean = features_mean
+
+ self.features_std = features_std
+
+
+ #==========================================================================
+ def project(self, feature):
+ """
+ This function computes a vector of scores for each sample in the input
+ array of features. The following steps are applied:
+
+ 1. First, the input data is mean-std normalized using mean and std of the
+ real class only.
+
+ 2. The input features are next classified using pre-trained GMM machine.
+
+ Set ``performs_projection = True`` in the constructor to enable this function.
+ It is assured that the :py:meth:`load_projector` was **called before** the
+ ``project`` function is executed.
+
+ **Parameters:**
+
+ ``feature`` : FrameContainer or 2D :py:class:`numpy.ndarray`
+ Two types of inputs are accepted.
+ A Frame Container conteining the features of an individual,
+ see ``bob.bio.video.utils.FrameContainer``.
+ Or a 2D feature array of the size (N_samples x N_features).
+
+ **Returns:**
+
+ ``scores`` : 1D :py:class:`numpy.ndarray`
+ Vector of scores. Scores for the real class are expected to be
+ higher, than the scores of the negative / attack class.
+ In this case scores are the weighted log probabilities.
+ """
+
+ # 1. Convert input array to numpy array if necessary.
+ if isinstance(feature, FrameContainer): # if FrameContainer convert to 2D numpy array
+
+ features_array = self.convert_frame_cont_to_array(feature)
+
+ else:
+
+ features_array = feature
+
+ features_array_norm, _, _ = self.mean_std_normalize(features_array, self.features_mean, self.features_std)
+
+ scores = self.machine.score_samples( features_array_norm )
+
+ return scores
+
+
+ #==========================================================================
+ def score(self, toscore):
+ """
+ Returns a probability of a sample being a real class.
+
+ **Parameters:**
+
+ ``toscore`` : 1D :py:class:`numpy.ndarray`
+ Vector with scores for each frame/sample defining the probability
+ of the frame being a sample of the real class.
+
+ **Returns:**
+
+ ``score`` : [:py:class:`float`]
+ If ``frame_level_scores_flag = False`` a single score is returned.
+ One score per video. This score is placed into a list, because
+ the ``score`` must be an iterable.
+ Score is a probability of a sample being a real class.
+ If ``frame_level_scores_flag = True`` a list of scores is returned.
+ One score per frame/sample.
+ """
+
+ if self.frame_level_scores_flag:
+
+ score = list(toscore)
+
+ else:
+
+ score = [np.mean( toscore )] # compute a single score per video
+
+ return score
+
diff --git a/bob/pad/face/algorithm/VideoLRPadAlgorithm.py b/bob/pad/face/algorithm/VideoLRPadAlgorithm.py
index a078fb6b9ad3cd0bac4445a293e59da3abcba276..833bd858923eea2051cf0b938dce35348683728b 100644
--- a/bob/pad/face/algorithm/VideoLRPadAlgorithm.py
+++ b/bob/pad/face/algorithm/VideoLRPadAlgorithm.py
@@ -25,7 +25,7 @@ import bob.io.base
class VideoLRPadAlgorithm(Algorithm):
"""
- This class is designed to Logistic Regression classifier given Frame Containers
+ This class is designed to train Logistic Regression classifier given Frame Containers
with features of real and attack classes. The procedure is the following:
1. First, the input data is mean-std normalized using mean and std of the
@@ -255,8 +255,7 @@ class VideoLRPadAlgorithm(Algorithm):
**Returns:**
``machine`` : object
- A trained LR machine. The mean-std normalizers are also set in the
- machine.
+ A trained LR machine.
``features_mean`` : 1D :py:class:`numpy.ndarray`
Mean of the features.
diff --git a/bob/pad/face/algorithm/__init__.py b/bob/pad/face/algorithm/__init__.py
index 3ef1ea1c5da23998f47a172c21121658933c4e3e..eeb27d59b563e895d3bd2f975fc87cb24060a228 100644
--- a/bob/pad/face/algorithm/__init__.py
+++ b/bob/pad/face/algorithm/__init__.py
@@ -1,6 +1,7 @@
from .VideoSvmPadAlgorithm import VideoSvmPadAlgorithm
from .VideoCascadeSvmPadAlgorithm import VideoCascadeSvmPadAlgorithm
from .VideoLRPadAlgorithm import VideoLRPadAlgorithm
+from .VideoGmmPadAlgorithm import VideoGmmPadAlgorithm
def __appropriate__(*args):
"""Says object was actually declared here, and not in the import module.
@@ -24,5 +25,6 @@ __appropriate__(
VideoSvmPadAlgorithm,
VideoCascadeSvmPadAlgorithm,
VideoLRPadAlgorithm,
+ VideoGmmPadAlgorithm,
)
__all__ = [_ for _ in dir() if not _.startswith('_')]
diff --git a/bob/pad/face/config/algorithm/video_cascade_svm_pad_algorithm.py b/bob/pad/face/config/algorithm/video_cascade_svm_pad_algorithm.py
index edd34b0123b256c720ba66d6fcd3ebc208f56c7d..f0ee742ea33ee5226ca752f5caabadb0d4569ed4 100644
--- a/bob/pad/face/config/algorithm/video_cascade_svm_pad_algorithm.py
+++ b/bob/pad/face/config/algorithm/video_cascade_svm_pad_algorithm.py
@@ -241,3 +241,26 @@ algorithm_n2_gamma_01_video_level = VideoCascadeSvmPadAlgorithm(machine_type = M
frame_level_scores_flag = FRAME_LEVEL_SCORES_FLAG)
+#=======================================================================================
+
+# Test the cascade of two-class SVMs.
+
+MACHINE_TYPE = 'C_SVC'
+KERNEL_TYPE = 'RBF'
+TRAINER_GRID_SEARCH_PARAMS = {'cost': 1, 'gamma': 0.01}
+N = 2
+POS_SCORES_SLOPE = 0.01
+FRAME_LEVEL_SCORES_FLAG = True
+
+algorithm_n2_two_class_svm_c1_gamma_001 = VideoCascadeSvmPadAlgorithm(machine_type = MACHINE_TYPE,
+ kernel_type = KERNEL_TYPE,
+ svm_kwargs = TRAINER_GRID_SEARCH_PARAMS,
+ N = N,
+ pos_scores_slope = POS_SCORES_SLOPE,
+ frame_level_scores_flag = FRAME_LEVEL_SCORES_FLAG)
+
+
+
+
+
+
diff --git a/bob/pad/face/config/algorithm/video_gmm_pad_algorithm.py b/bob/pad/face/config/algorithm/video_gmm_pad_algorithm.py
new file mode 100644
index 0000000000000000000000000000000000000000..e46e285d97a7fbbf9561b62a488d90bd4d5eac15
--- /dev/null
+++ b/bob/pad/face/config/algorithm/video_gmm_pad_algorithm.py
@@ -0,0 +1,257 @@
+#!/usr/bin/env python
+
+from bob.pad.face.algorithm import VideoGmmPadAlgorithm
+
+
+#=======================================================================================
+# Define instances here:
+
+N_COMPONENTS = 2
+FRAME_LEVEL_SCORES_FLAG = True
+
+algorithm_gmm_2 = VideoGmmPadAlgorithm(n_components = N_COMPONENTS,
+ frame_level_scores_flag = FRAME_LEVEL_SCORES_FLAG)
+
+N_COMPONENTS = 3
+FRAME_LEVEL_SCORES_FLAG = True
+
+algorithm_gmm_3 = VideoGmmPadAlgorithm(n_components = N_COMPONENTS,
+ frame_level_scores_flag = FRAME_LEVEL_SCORES_FLAG)
+
+N_COMPONENTS = 4
+FRAME_LEVEL_SCORES_FLAG = True
+
+algorithm_gmm_4 = VideoGmmPadAlgorithm(n_components = N_COMPONENTS,
+ frame_level_scores_flag = FRAME_LEVEL_SCORES_FLAG)
+
+N_COMPONENTS = 5
+FRAME_LEVEL_SCORES_FLAG = True
+
+algorithm_gmm_5 = VideoGmmPadAlgorithm(n_components = N_COMPONENTS,
+ frame_level_scores_flag = FRAME_LEVEL_SCORES_FLAG)
+
+N_COMPONENTS = 6
+FRAME_LEVEL_SCORES_FLAG = True
+
+algorithm_gmm_6 = VideoGmmPadAlgorithm(n_components = N_COMPONENTS,
+ frame_level_scores_flag = FRAME_LEVEL_SCORES_FLAG)
+
+N_COMPONENTS = 7
+FRAME_LEVEL_SCORES_FLAG = True
+
+algorithm_gmm_7 = VideoGmmPadAlgorithm(n_components = N_COMPONENTS,
+ frame_level_scores_flag = FRAME_LEVEL_SCORES_FLAG)
+
+N_COMPONENTS = 8
+FRAME_LEVEL_SCORES_FLAG = True
+
+algorithm_gmm_8 = VideoGmmPadAlgorithm(n_components = N_COMPONENTS,
+ frame_level_scores_flag = FRAME_LEVEL_SCORES_FLAG)
+
+N_COMPONENTS = 9
+FRAME_LEVEL_SCORES_FLAG = True
+
+algorithm_gmm_9 = VideoGmmPadAlgorithm(n_components = N_COMPONENTS,
+ frame_level_scores_flag = FRAME_LEVEL_SCORES_FLAG)
+
+N_COMPONENTS = 10
+FRAME_LEVEL_SCORES_FLAG = True
+
+algorithm_gmm_10 = VideoGmmPadAlgorithm(n_components = N_COMPONENTS,
+ frame_level_scores_flag = FRAME_LEVEL_SCORES_FLAG)
+
+
+#=======================================================================================
+# above 10 Gaussians:
+
+N_COMPONENTS = 12
+FRAME_LEVEL_SCORES_FLAG = True
+
+algorithm_gmm_12 = VideoGmmPadAlgorithm(n_components = N_COMPONENTS,
+ frame_level_scores_flag = FRAME_LEVEL_SCORES_FLAG)
+
+N_COMPONENTS = 14
+FRAME_LEVEL_SCORES_FLAG = True
+
+algorithm_gmm_14 = VideoGmmPadAlgorithm(n_components = N_COMPONENTS,
+ frame_level_scores_flag = FRAME_LEVEL_SCORES_FLAG)
+
+N_COMPONENTS = 16
+FRAME_LEVEL_SCORES_FLAG = True
+
+algorithm_gmm_16 = VideoGmmPadAlgorithm(n_components = N_COMPONENTS,
+ frame_level_scores_flag = FRAME_LEVEL_SCORES_FLAG)
+
+N_COMPONENTS = 18
+FRAME_LEVEL_SCORES_FLAG = True
+
+algorithm_gmm_18 = VideoGmmPadAlgorithm(n_components = N_COMPONENTS,
+ frame_level_scores_flag = FRAME_LEVEL_SCORES_FLAG)
+
+N_COMPONENTS = 20
+FRAME_LEVEL_SCORES_FLAG = True
+
+algorithm_gmm_20 = VideoGmmPadAlgorithm(n_components = N_COMPONENTS,
+ frame_level_scores_flag = FRAME_LEVEL_SCORES_FLAG)
+
+
+#=======================================================================================
+# above 20 Gaussians:
+
+N_COMPONENTS = 25
+FRAME_LEVEL_SCORES_FLAG = True
+
+algorithm_gmm_25 = VideoGmmPadAlgorithm(n_components = N_COMPONENTS,
+ frame_level_scores_flag = FRAME_LEVEL_SCORES_FLAG)
+
+N_COMPONENTS = 30
+FRAME_LEVEL_SCORES_FLAG = True
+
+algorithm_gmm_30 = VideoGmmPadAlgorithm(n_components = N_COMPONENTS,
+ frame_level_scores_flag = FRAME_LEVEL_SCORES_FLAG)
+
+N_COMPONENTS = 35
+FRAME_LEVEL_SCORES_FLAG = True
+
+algorithm_gmm_35 = VideoGmmPadAlgorithm(n_components = N_COMPONENTS,
+ frame_level_scores_flag = FRAME_LEVEL_SCORES_FLAG)
+
+N_COMPONENTS = 40
+FRAME_LEVEL_SCORES_FLAG = True
+
+algorithm_gmm_40 = VideoGmmPadAlgorithm(n_components = N_COMPONENTS,
+ frame_level_scores_flag = FRAME_LEVEL_SCORES_FLAG)
+
+N_COMPONENTS = 45
+FRAME_LEVEL_SCORES_FLAG = True
+
+algorithm_gmm_45 = VideoGmmPadAlgorithm(n_components = N_COMPONENTS,
+ frame_level_scores_flag = FRAME_LEVEL_SCORES_FLAG)
+
+N_COMPONENTS = 50
+FRAME_LEVEL_SCORES_FLAG = True
+
+algorithm_gmm_50 = VideoGmmPadAlgorithm(n_components = N_COMPONENTS,
+ frame_level_scores_flag = FRAME_LEVEL_SCORES_FLAG)
+
+
+#=======================================================================================
+# above 50 Gaussians:
+
+N_COMPONENTS = 60
+FRAME_LEVEL_SCORES_FLAG = True
+
+algorithm_gmm_60 = VideoGmmPadAlgorithm(n_components = N_COMPONENTS,
+ frame_level_scores_flag = FRAME_LEVEL_SCORES_FLAG)
+
+N_COMPONENTS = 70
+FRAME_LEVEL_SCORES_FLAG = True
+
+algorithm_gmm_70 = VideoGmmPadAlgorithm(n_components = N_COMPONENTS,
+ frame_level_scores_flag = FRAME_LEVEL_SCORES_FLAG)
+
+N_COMPONENTS = 80
+FRAME_LEVEL_SCORES_FLAG = True
+
+algorithm_gmm_80 = VideoGmmPadAlgorithm(n_components = N_COMPONENTS,
+ frame_level_scores_flag = FRAME_LEVEL_SCORES_FLAG)
+
+N_COMPONENTS = 90
+FRAME_LEVEL_SCORES_FLAG = True
+
+algorithm_gmm_90 = VideoGmmPadAlgorithm(n_components = N_COMPONENTS,
+ frame_level_scores_flag = FRAME_LEVEL_SCORES_FLAG)
+
+N_COMPONENTS = 100
+FRAME_LEVEL_SCORES_FLAG = True
+
+algorithm_gmm_100 = VideoGmmPadAlgorithm(n_components = N_COMPONENTS,
+ frame_level_scores_flag = FRAME_LEVEL_SCORES_FLAG)
+
+
+
+#=======================================================================================
+# 50 Gaussians, different random seeds:
+
+N_COMPONENTS = 50
+RANDOM_STATE = 0
+FRAME_LEVEL_SCORES_FLAG = True
+
+algorithm_gmm_50_0 = VideoGmmPadAlgorithm(n_components = N_COMPONENTS,
+ random_state = RANDOM_STATE,
+ frame_level_scores_flag = FRAME_LEVEL_SCORES_FLAG)
+
+N_COMPONENTS = 50
+RANDOM_STATE = 1
+FRAME_LEVEL_SCORES_FLAG = True
+
+algorithm_gmm_50_1 = VideoGmmPadAlgorithm(n_components = N_COMPONENTS,
+ random_state = RANDOM_STATE,
+ frame_level_scores_flag = FRAME_LEVEL_SCORES_FLAG)
+
+N_COMPONENTS = 50
+RANDOM_STATE = 2
+FRAME_LEVEL_SCORES_FLAG = True
+
+algorithm_gmm_50_2 = VideoGmmPadAlgorithm(n_components = N_COMPONENTS,
+ random_state = RANDOM_STATE,
+ frame_level_scores_flag = FRAME_LEVEL_SCORES_FLAG)
+
+N_COMPONENTS = 50
+RANDOM_STATE = 3
+FRAME_LEVEL_SCORES_FLAG = True
+
+algorithm_gmm_50_3 = VideoGmmPadAlgorithm(n_components = N_COMPONENTS,
+ random_state = RANDOM_STATE,
+ frame_level_scores_flag = FRAME_LEVEL_SCORES_FLAG)
+
+N_COMPONENTS = 50
+RANDOM_STATE = 4
+FRAME_LEVEL_SCORES_FLAG = True
+
+algorithm_gmm_50_4 = VideoGmmPadAlgorithm(n_components = N_COMPONENTS,
+ random_state = RANDOM_STATE,
+ frame_level_scores_flag = FRAME_LEVEL_SCORES_FLAG)
+
+N_COMPONENTS = 50
+RANDOM_STATE = 5
+FRAME_LEVEL_SCORES_FLAG = True
+
+algorithm_gmm_50_5 = VideoGmmPadAlgorithm(n_components = N_COMPONENTS,
+ random_state = RANDOM_STATE,
+ frame_level_scores_flag = FRAME_LEVEL_SCORES_FLAG)
+
+N_COMPONENTS = 50
+RANDOM_STATE = 6
+FRAME_LEVEL_SCORES_FLAG = True
+
+algorithm_gmm_50_6 = VideoGmmPadAlgorithm(n_components = N_COMPONENTS,
+ random_state = RANDOM_STATE,
+ frame_level_scores_flag = FRAME_LEVEL_SCORES_FLAG)
+
+N_COMPONENTS = 50
+RANDOM_STATE = 7
+FRAME_LEVEL_SCORES_FLAG = True
+
+algorithm_gmm_50_7 = VideoGmmPadAlgorithm(n_components = N_COMPONENTS,
+ random_state = RANDOM_STATE,
+ frame_level_scores_flag = FRAME_LEVEL_SCORES_FLAG)
+
+N_COMPONENTS = 50
+RANDOM_STATE = 8
+FRAME_LEVEL_SCORES_FLAG = True
+
+algorithm_gmm_50_8 = VideoGmmPadAlgorithm(n_components = N_COMPONENTS,
+ random_state = RANDOM_STATE,
+ frame_level_scores_flag = FRAME_LEVEL_SCORES_FLAG)
+
+N_COMPONENTS = 50
+RANDOM_STATE = 9
+FRAME_LEVEL_SCORES_FLAG = True
+
+algorithm_gmm_50_9 = VideoGmmPadAlgorithm(n_components = N_COMPONENTS,
+ random_state = RANDOM_STATE,
+ frame_level_scores_flag = FRAME_LEVEL_SCORES_FLAG)
+
+
+
diff --git a/setup.py b/setup.py
index 9d1c453f075068e2173678eaad4dc717eca4273f..f92af0e183a59e2247598341c5a0dd89416c8dcb 100644
--- a/setup.py
+++ b/setup.py
@@ -120,6 +120,7 @@ setup(
'algorithm-n2-gamma-005 = bob.pad.face.config.algorithm.video_cascade_svm_pad_algorithm:algorithm_n2_gamma_005',
'algorithm-n2-gamma-001 = bob.pad.face.config.algorithm.video_cascade_svm_pad_algorithm:algorithm_n2_gamma_001',
'algorithm-n2-gamma-01-video-level = bob.pad.face.config.algorithm.video_cascade_svm_pad_algorithm:algorithm_n2_gamma_01_video_level',
+ 'algorithm-n2-two-class-svm-c1-gamma-001 = bob.pad.face.config.algorithm.video_cascade_svm_pad_algorithm:algorithm_n2_two_class_svm_c1_gamma_001',
# for grid search experiments with cascade of SVMs N = 10
'algorithm-n10-gamma-01 = bob.pad.face.config.algorithm.video_cascade_svm_pad_algorithm:algorithm_n10_gamma_01',
@@ -135,6 +136,43 @@ setup(
'algorithm-n20-gamma-001 = bob.pad.face.config.algorithm.video_cascade_svm_pad_algorithm:algorithm_n20_gamma_001',
'algorithm-n20-gamma-0005 = bob.pad.face.config.algorithm.video_cascade_svm_pad_algorithm:algorithm_n20_gamma_0005',
'algorithm-n20-gamma-0001 = bob.pad.face.config.algorithm.video_cascade_svm_pad_algorithm:algorithm_n20_gamma_0001',
+
+ # for grid search experiments using GMM
+ 'algorithm-gmm-2 = bob.pad.face.config.algorithm.video_gmm_pad_algorithm:algorithm_gmm_2',
+ 'algorithm-gmm-3 = bob.pad.face.config.algorithm.video_gmm_pad_algorithm:algorithm_gmm_3',
+ 'algorithm-gmm-4 = bob.pad.face.config.algorithm.video_gmm_pad_algorithm:algorithm_gmm_4',
+ 'algorithm-gmm-5 = bob.pad.face.config.algorithm.video_gmm_pad_algorithm:algorithm_gmm_5',
+ 'algorithm-gmm-6 = bob.pad.face.config.algorithm.video_gmm_pad_algorithm:algorithm_gmm_6',
+ 'algorithm-gmm-7 = bob.pad.face.config.algorithm.video_gmm_pad_algorithm:algorithm_gmm_7',
+ 'algorithm-gmm-8 = bob.pad.face.config.algorithm.video_gmm_pad_algorithm:algorithm_gmm_8',
+ 'algorithm-gmm-9 = bob.pad.face.config.algorithm.video_gmm_pad_algorithm:algorithm_gmm_9',
+ 'algorithm-gmm-10 = bob.pad.face.config.algorithm.video_gmm_pad_algorithm:algorithm_gmm_10',
+ 'algorithm-gmm-12 = bob.pad.face.config.algorithm.video_gmm_pad_algorithm:algorithm_gmm_12',
+ 'algorithm-gmm-14 = bob.pad.face.config.algorithm.video_gmm_pad_algorithm:algorithm_gmm_14',
+ 'algorithm-gmm-16 = bob.pad.face.config.algorithm.video_gmm_pad_algorithm:algorithm_gmm_16',
+ 'algorithm-gmm-18 = bob.pad.face.config.algorithm.video_gmm_pad_algorithm:algorithm_gmm_18',
+ 'algorithm-gmm-20 = bob.pad.face.config.algorithm.video_gmm_pad_algorithm:algorithm_gmm_20',
+ 'algorithm-gmm-25 = bob.pad.face.config.algorithm.video_gmm_pad_algorithm:algorithm_gmm_25',
+ 'algorithm-gmm-30 = bob.pad.face.config.algorithm.video_gmm_pad_algorithm:algorithm_gmm_30',
+ 'algorithm-gmm-35 = bob.pad.face.config.algorithm.video_gmm_pad_algorithm:algorithm_gmm_35',
+ 'algorithm-gmm-40 = bob.pad.face.config.algorithm.video_gmm_pad_algorithm:algorithm_gmm_40',
+ 'algorithm-gmm-45 = bob.pad.face.config.algorithm.video_gmm_pad_algorithm:algorithm_gmm_45',
+ 'algorithm-gmm-50 = bob.pad.face.config.algorithm.video_gmm_pad_algorithm:algorithm_gmm_50',
+ 'algorithm-gmm-60 = bob.pad.face.config.algorithm.video_gmm_pad_algorithm:algorithm_gmm_60',
+ 'algorithm-gmm-70 = bob.pad.face.config.algorithm.video_gmm_pad_algorithm:algorithm_gmm_70',
+ 'algorithm-gmm-80 = bob.pad.face.config.algorithm.video_gmm_pad_algorithm:algorithm_gmm_80',
+ 'algorithm-gmm-90 = bob.pad.face.config.algorithm.video_gmm_pad_algorithm:algorithm_gmm_90',
+ 'algorithm-gmm-100 = bob.pad.face.config.algorithm.video_gmm_pad_algorithm:algorithm_gmm_100',
+ 'algorithm-gmm-50-0 = bob.pad.face.config.algorithm.video_gmm_pad_algorithm:algorithm_gmm_50_0',
+ 'algorithm-gmm-50-1 = bob.pad.face.config.algorithm.video_gmm_pad_algorithm:algorithm_gmm_50_1',
+ 'algorithm-gmm-50-2 = bob.pad.face.config.algorithm.video_gmm_pad_algorithm:algorithm_gmm_50_2',
+ 'algorithm-gmm-50-3 = bob.pad.face.config.algorithm.video_gmm_pad_algorithm:algorithm_gmm_50_3',
+ 'algorithm-gmm-50-4 = bob.pad.face.config.algorithm.video_gmm_pad_algorithm:algorithm_gmm_50_4',
+ 'algorithm-gmm-50-5 = bob.pad.face.config.algorithm.video_gmm_pad_algorithm:algorithm_gmm_50_5',
+ 'algorithm-gmm-50-6 = bob.pad.face.config.algorithm.video_gmm_pad_algorithm:algorithm_gmm_50_6',
+ 'algorithm-gmm-50-7 = bob.pad.face.config.algorithm.video_gmm_pad_algorithm:algorithm_gmm_50_7',
+ 'algorithm-gmm-50-8 = bob.pad.face.config.algorithm.video_gmm_pad_algorithm:algorithm_gmm_50_8',
+ 'algorithm-gmm-50-9 = bob.pad.face.config.algorithm.video_gmm_pad_algorithm:algorithm_gmm_50_9',
],
# registered grid configurations: