| Multivariate Pattern Analysis in Python

### Navigation

- index
- next |
- previous |
- ExpPsy Project |
- NeuroDebian Project |
- PyMVPA 0.4.x Home |
- PyMVPA Home |
- Documentation »
- Module Reference »

This content refers to the previous stable release of PyMVPA. Please visit www.pymvpa.org for the most recent version of PyMVPA and its documentation.

# clfs.meta

## Module: `clfs.meta`

Inheritance diagram for `mvpa.clfs.meta`:

Classes for meta classifiers – classifiers which use other classifiers

Meta Classifiers can be grouped according to their function as

group BoostedClassifiers:
| CombinedClassifier MulticlassClassifier SplitClassifier
group ProxyClassifiers:
| ProxyClassifier BinaryClassifier MappedClassifier FeatureSelectionClassifier
group PredictionsCombiners for CombinedClassifier:
| PredictionsCombiner MaximalVote MeanPrediction

## Classes

### `BinaryClassifier`

class `mvpa.clfs.meta.``BinaryClassifier`(clf, poslabels, neglabels, **kwargs)

  Bases: `mvpa.clfs.meta.ProxyClassifier`

  ProxyClassifier which maps set of two labels into +1 and -1

  Note

  Available state variables:

  - feature_ids: Feature IDS which were used for the actual training.
  - predicting_time+: Time (in seconds) which took classifier to predict
  - predictions+: Most recent set of predictions
  - trained_dataset: The dataset it has been trained on
  - trained_labels+: Set of unique labels it has been trained on
  - trained_nsamples+: Number of samples it has been trained on
  - training_confusion: Confusion matrix of learning performance
  - training_time+: Time (in seconds) which took classifier to train
  - values+: Internal classifier values the most recent predictions are based on

  (States enabled by default are listed with +)

  See also

  Please refer to the documentation of the base class for more information:

  `ProxyClassifier`

  Parameters:

  - clf (Classifier) – classifier to use
  - poslabels (list) – list of labels which are treated as +1 category
  - neglabels (list) – list of labels which are treated as -1 category
  - enable_states (None or list of basestring) – Names of the state variables which should be enabled additionally to default ones
  - disable_states (None or list of basestring) – Names of the state variables which should be disabled

### `BoostedClassifier`

class `mvpa.clfs.meta.``BoostedClassifier`(clfs=None, propagate_states=True, harvest_attribs=None, copy_attribs='copy', **kwargs)

  Bases: `mvpa.clfs.base.Classifier`, `mvpa.misc.state.Harvestable`

  Classifier containing the farm of other classifiers.

  Should rarely be used directly. Use one of its childs instead

  Note

  Available state variables:

  - feature_ids: Feature IDS which were used for the actual training.
  - harvested: Store specified attributes of classifiers at each split
  - predicting_time+: Time (in seconds) which took classifier to predict
  - predictions+: Most recent set of predictions
  - raw_predictions: Predictions obtained from each classifier
  - raw_values: Values obtained from each classifier
  - trained_dataset: The dataset it has been trained on
  - trained_labels+: Set of unique labels it has been trained on
  - trained_nsamples+: Number of samples it has been trained on
  - training_confusion: Confusion matrix of learning performance
  - training_time+: Time (in seconds) which took classifier to train
  - values+: Internal classifier values the most recent predictions are based on

  (States enabled by default are listed with +)

  See also

  Please refer to the documentation of the base classes for more information:

  `Classifier`, `Harvestable`

  Initialize the instance.

  Parameters:

  - clfs (list) – list of classifier instances to use (slave classifiers)
  - propagate_states (bool) – either to propagate enabled states into slave classifiers. It is in effect only when slaves get assigned - so if state is enabled not during construction, it would not necessarily propagate into slaves
  - enable_states (None or list of basestring) – Names of the state variables which should be enabled additionally to default ones
  - disable_states (None or list of basestring) – Names of the state variables which should be disabled
  - harvest_attribs (list of basestr or dicts) – What attributes of call to store and return within harvested state variable. If an item is a dictionary, following keys are used [‘name’, ‘copy’]
  - copy_attribs (None or basestr) – Default copying. If None – no copying, ‘copy’ - shallow copying, ‘deepcopy’ – deepcopying

  `clfs`

    Used classifiers

  `getSensitivityAnalyzer`(**kwargs)

    Return an appropriate SensitivityAnalyzer

  `untrain`()

    Untrain BoostedClassifier

    Has to untrain any known classifier

### `ClassifierCombiner`

class `mvpa.clfs.meta.``ClassifierCombiner`(clf, variables=None)

  Bases: `mvpa.clfs.meta.PredictionsCombiner`

  Provides a decision using training a classifier on predictions/values

  TODO: implement

  Note

  Available state variables:

  - predictions+: Trained predictions

  (States enabled by default are listed with +)

  See also

  Please refer to the documentation of the base class for more information:

  `PredictionsCombiner`

  Initialize ClassifierCombiner

  Parameters:

  - clf (Classifier) – Classifier to train on the predictions
  - variables (list of basestring) – List of state variables stored in ‘combined’ classifiers, which to use as features for training this classifier
  - enable_states (None or list of basestring) – Names of the state variables which should be enabled additionally to default ones
  - disable_states (None or list of basestring) – Names of the state variables which should be disabled

  `untrain`()

    It might be needed to untrain used classifier

### `CombinedClassifier`

class `mvpa.clfs.meta.``CombinedClassifier`(clfs=None, combiner=None, **kwargs)

  Bases: `mvpa.clfs.meta.BoostedClassifier`

  BoostedClassifier which combines predictions using some PredictionsCombiner functor.

  Note

  Available state variables:

  - feature_ids: Feature IDS which were used for the actual training.
  - harvested: Store specified attributes of classifiers at each split
  - predicting_time+: Time (in seconds) which took classifier to predict
  - predictions+: Most recent set of predictions
  - raw_predictions: Predictions obtained from each classifier
  - raw_values: Values obtained from each classifier
  - trained_dataset: The dataset it has been trained on
  - trained_labels+: Set of unique labels it has been trained on
  - trained_nsamples+: Number of samples it has been trained on
  - training_confusion: Confusion matrix of learning performance
  - training_time+: Time (in seconds) which took classifier to train
  - values+: Internal classifier values the most recent predictions are based on

  (States enabled by default are listed with +)

  See also

  Please refer to the documentation of the base class for more information:

  `BoostedClassifier`

  Initialize the instance.

  Parameters:

  - clfs (list of Classifier) – list of classifier instances to use
  - combiner (PredictionsCombiner) – callable which takes care about combining multiple results into a single one (e.g. maximal vote for classification, MeanPrediction for regression))
  - enable_states (None or list of basestring) – Names of the state variables which should be enabled additionally to default ones
  - disable_states (None or list of basestring) – Names of the state variables which should be disabled
  - propagate_states (bool) – either to propagate enabled states into slave classifiers. It is in effect only when slaves get assigned - so if state is enabled not during construction, it would not necessarily propagate into slaves
  - harvest_attribs (list of basestr or dicts) – What attributes of call to store and return within harvested state variable. If an item is a dictionary, following keys are used [‘name’, ‘copy’]
  - copy_attribs (None or basestr) – Default copying. If None – no copying, ‘copy’ - shallow copying, ‘deepcopy’ – deepcopying

  NB: combiner might need to operate not on ‘predictions’ descrete
    labels but rather on raw ‘class’ values classifiers estimate (which is pretty much what is stored under values
  `combiner`

    Used combiner to derive a single result

  `summary`()

    Provide summary for the CombinedClassifier.

  `untrain`()

    Untrain CombinedClassifier

### `FeatureSelectionClassifier`

class `mvpa.clfs.meta.``FeatureSelectionClassifier`(clf, feature_selection, testdataset=None, **kwargs)

  Bases: `mvpa.clfs.meta.ProxyClassifier`

  ProxyClassifier which uses some FeatureSelection prior training.

  FeatureSelection is used first to select features for the classifier to use for prediction. Internally it would rely on MappedClassifier which would use created MaskMapper.

  TODO: think about removing overhead of retraining the same classifier if feature selection was carried out with the same classifier already. It has been addressed by adding .trained property to classifier, but now we should expclitely use isTrained here if we want... need to think more

  Note

  Available state variables:

  - feature_ids: Feature IDS which were used for the actual training.
  - predicting_time+: Time (in seconds) which took classifier to predict
  - predictions+: Most recent set of predictions
  - trained_dataset: The dataset it has been trained on
  - trained_labels+: Set of unique labels it has been trained on
  - trained_nsamples+: Number of samples it has been trained on
  - training_confusion: Confusion matrix of learning performance
  - training_time+: Time (in seconds) which took classifier to train
  - values+: Internal classifier values the most recent predictions are based on

  (States enabled by default are listed with +)

  See also

  Please refer to the documentation of the base class for more information:

  `ProxyClassifier`

  Initialize the instance

  Parameters:

  - clf (Classifier) – classifier based on which mask classifiers is created
  - feature_selection (FeatureSelection) – whatever FeatureSelection comes handy
  - testdataset (Dataset) – optional dataset which would be given on call to feature_selection
  - enable_states (None or list of basestring) – Names of the state variables which should be enabled additionally to default ones
  - disable_states (None or list of basestring) – Names of the state variables which should be disabled

  `feature_selection`

    Used FeatureSelection

  `getSensitivityAnalyzer`(*args_, **kwargs_)
  `maskclf`

    Used MappedClassifier

  `setTestDataset`(testdataset)

    Set testing dataset to be used for feature selection

  `testdataset`
  `untrain`()

    Untrain FeatureSelectionClassifier

    Has to untrain any known classifier

### `MappedClassifier`

class `mvpa.clfs.meta.``MappedClassifier`(clf, mapper, **kwargs)

  Bases: `mvpa.clfs.meta.ProxyClassifier`

  ProxyClassifier which uses some mapper prior training/testing.

  MaskMapper can be used just a subset of features to train/classify. Having such classifier we can easily create a set of classifiers for BoostedClassifier, where each classifier operates on some set of features, e.g. set of best spheres from SearchLight, set of ROIs selected elsewhere. It would be different from simply applying whole mask over the dataset, since here initial decision is made by each classifier and then later on they vote for the final decision across the set of classifiers.

  Note

  Available state variables:

  - feature_ids: Feature IDS which were used for the actual training.
  - predicting_time+: Time (in seconds) which took classifier to predict
  - predictions+: Most recent set of predictions
  - trained_dataset: The dataset it has been trained on
  - trained_labels+: Set of unique labels it has been trained on
  - trained_nsamples+: Number of samples it has been trained on
  - training_confusion: Confusion matrix of learning performance
  - training_time+: Time (in seconds) which took classifier to train
  - values+: Internal classifier values the most recent predictions are based on

  (States enabled by default are listed with +)

  See also

  Please refer to the documentation of the base class for more information:

  `ProxyClassifier`

  Initialize the instance

  Parameters:

  - clf (Classifier) – classifier based on which mask classifiers is created
  - mapper – whatever Mapper comes handy
  - enable_states (None or list of basestring) – Names of the state variables which should be enabled additionally to default ones
  - disable_states (None or list of basestring) – Names of the state variables which should be disabled

  `getSensitivityAnalyzer`(*args_, **kwargs_)
  `mapper`

    Used mapper

### `MaximalVote`

class `mvpa.clfs.meta.``MaximalVote`

  Bases: `mvpa.clfs.meta.PredictionsCombiner`

  Provides a decision using maximal vote rule

  Note

  Available state variables:

  - all_label_counts: Counts across classifiers for each label/sample
  - predictions+: Voted predictions

  (States enabled by default are listed with +)

  See also

  Please refer to the documentation of the base class for more information:

  `PredictionsCombiner`

  XXX Might get a parameter to use raw decision values if voting is not unambigous (ie two classes have equal number of votes

  Parameters:

  - enable_states (None or list of basestring) – Names of the state variables which should be enabled additionally to default ones
  - disable_states (None or list of basestring) – Names of the state variables which should be disabled

### `MeanPrediction`

class `mvpa.clfs.meta.``MeanPrediction`(descr=None, **kwargs)

  Bases: `mvpa.clfs.meta.PredictionsCombiner`

  Provides a decision by taking mean of the results

  Note

  Available state variables:

  - predictions+: Mean predictions

  (States enabled by default are listed with +)

  See also

  Please refer to the documentation of the base class for more information:

  `PredictionsCombiner`

### `MulticlassClassifier`

class `mvpa.clfs.meta.``MulticlassClassifier`(clf, bclf_type='1-vs-1', **kwargs)

  Bases: `mvpa.clfs.meta.CombinedClassifier`

  CombinedClassifier to perform multiclass using a list of BinaryClassifier.

  such as 1-vs-1 (ie in pairs like libsvm doesn) or 1-vs-all (which is yet to think about)

  Note

  Available state variables:

  - feature_ids: Feature IDS which were used for the actual training.
  - harvested: Store specified attributes of classifiers at each split
  - predicting_time+: Time (in seconds) which took classifier to predict
  - predictions+: Most recent set of predictions
  - raw_predictions: Predictions obtained from each classifier
  - raw_values: Values obtained from each classifier
  - trained_dataset: The dataset it has been trained on
  - trained_labels+: Set of unique labels it has been trained on
  - trained_nsamples+: Number of samples it has been trained on
  - training_confusion: Confusion matrix of learning performance
  - training_time+: Time (in seconds) which took classifier to train
  - values+: Internal classifier values the most recent predictions are based on

  (States enabled by default are listed with +)

  See also

  Please refer to the documentation of the base class for more information:

  `CombinedClassifier`

  Initialize the instance

  Parameters:

  - clf (Classifier) – classifier based on which multiple classifiers are created for multiclass
  - bclf_type – “1-vs-1” or “1-vs-all”, determines the way to generate binary classifiers
  - enable_states (None or list of basestring) – Names of the state variables which should be enabled additionally to default ones
  - disable_states (None or list of basestring) – Names of the state variables which should be disabled
  - clfs (list of Classifier) – list of classifier instances to use
  - combiner (PredictionsCombiner) – callable which takes care about combining multiple results into a single one (e.g. maximal vote for classification, MeanPrediction for regression))
  - propagate_states (bool) – either to propagate enabled states into slave classifiers. It is in effect only when slaves get assigned - so if state is enabled not during construction, it would not necessarily propagate into slaves
  - harvest_attribs (list of basestr or dicts) – What attributes of call to store and return within harvested state variable. If an item is a dictionary, following keys are used [‘name’, ‘copy’]
  - copy_attribs (None or basestr) – Default copying. If None – no copying, ‘copy’ - shallow copying, ‘deepcopy’ – deepcopying

### `PredictionsCombiner`

class `mvpa.clfs.meta.``PredictionsCombiner`(descr=None, **kwargs)

  Bases: `mvpa.misc.state.ClassWithCollections`

  Base class for combining decisions of multiple classifiers

  `train`(clfs, dataset)

    PredictionsCombiner might need to be trained

    Parameters:

    - clfs (list of Classifier) – List of classifiers to combine. Has to be classifiers (not pure predictions), since combiner might use some other state variables (value’s) instead of pure prediction’s
    - dataset (Dataset) – training data in this case

### `ProxyClassifier`

class `mvpa.clfs.meta.``ProxyClassifier`(clf, **kwargs)

  Bases: `mvpa.clfs.base.Classifier`

  Classifier which decorates another classifier

  Possible uses:

  > - modify data somehow prior training/testing: * normalization * feature selection * modification
  > - optimized classifier?

  Note

  Available state variables:

  - feature_ids: Feature IDS which were used for the actual training.
  - predicting_time+: Time (in seconds) which took classifier to predict
  - predictions+: Most recent set of predictions
  - trained_dataset: The dataset it has been trained on
  - trained_labels+: Set of unique labels it has been trained on
  - trained_nsamples+: Number of samples it has been trained on
  - training_confusion: Confusion matrix of learning performance
  - training_time+: Time (in seconds) which took classifier to train
  - values+: Internal classifier values the most recent predictions are based on

  (States enabled by default are listed with +)

  See also

  Please refer to the documentation of the base class for more information:

  `Classifier`

  Initialize the instance

  Parameters:

  - clf (Classifier) – classifier based on which mask classifiers is created
  - enable_states (None or list of basestring) – Names of the state variables which should be enabled additionally to default ones
  - disable_states (None or list of basestring) – Names of the state variables which should be disabled

  `clf`

    Used Classifier

  `getSensitivityAnalyzer`(*args_, **kwargs_)
  `summary`()
  `untrain`()

    Untrain ProxyClassifier

### `SplitClassifier`

class `mvpa.clfs.meta.``SplitClassifier`(clf, splitter=<mvpa.datasets.splitters.NFoldSplitter object at 0xb217dec>, **kwargs)

  Bases: `mvpa.clfs.meta.CombinedClassifier`

  BoostedClassifier to work on splits of the data

  Note

  Available state variables:

  - confusion: Resultant confusion whenever classifier trained on 1 part and tested on 2nd part of each split
  - feature_ids: Feature IDS which were used for the actual training.
  - harvested: Store specified attributes of classifiers at each split
  - predicting_time+: Time (in seconds) which took classifier to predict
  - predictions+: Most recent set of predictions
  - raw_predictions: Predictions obtained from each classifier
  - raw_values: Values obtained from each classifier
  - splits: Store the actual splits of the data. Can be memory expensive
  - trained_dataset: The dataset it has been trained on
  - trained_labels+: Set of unique labels it has been trained on
  - trained_nsamples+: Number of samples it has been trained on
  - training_confusion: Confusion matrix of learning performance
  - training_time+: Time (in seconds) which took classifier to train
  - values+: Internal classifier values the most recent predictions are based on

  (States enabled by default are listed with +)

  See also

  Please refer to the documentation of the base class for more information:

  `CombinedClassifier`

  Initialize the instance

  Parameters:

  - clf (Classifier) – classifier based on which multiple classifiers are created for multiclass
  - splitter (Splitter) – Splitter to use to split the dataset prior training
  - enable_states (None or list of basestring) – Names of the state variables which should be enabled additionally to default ones
  - disable_states (None or list of basestring) – Names of the state variables which should be disabled
  - clfs (list of Classifier) – list of classifier instances to use
  - combiner (PredictionsCombiner) – callable which takes care about combining multiple results into a single one (e.g. maximal vote for classification, MeanPrediction for regression))
  - propagate_states (bool) – either to propagate enabled states into slave classifiers. It is in effect only when slaves get assigned - so if state is enabled not during construction, it would not necessarily propagate into slaves
  - harvest_attribs (list of basestr or dicts) – What attributes of call to store and return within harvested state variable. If an item is a dictionary, following keys are used [‘name’, ‘copy’]
  - copy_attribs (None or basestr) – Default copying. If None – no copying, ‘copy’ - shallow copying, ‘deepcopy’ – deepcopying

  `getSensitivityAnalyzer`(*args_, **kwargs_)
  `splitter`

    Splitter user by SplitClassifier

### `TreeClassifier`

class `mvpa.clfs.meta.``TreeClassifier`(clf, groups, **kwargs)

  Bases: `mvpa.clfs.meta.ProxyClassifier`

  TreeClassifier which allows to create hierarchy of classifiers

  Functions by grouping some labels into a single “meta-label” and training classifier first to separate between meta-labels. Then each group further proceeds with classification within each group.

  Possible scenarios:

      TreeClassifier(SVM(),
       {'animate':  ((1,2,3,4),
                     TreeClassifier(SVM(),
                         {'human': (('male', 'female'), SVM()),
                          'animals': (('monkey', 'dog'), SMLR())})),
        'inanimate': ((5,6,7,8), SMLR())})

  would create classifier which would first do binary classification to separate animate from inanimate, then for animate result it would separate to classify human vs animal and so on:

                       SVM
                     /                                  animate   inanimate
                 /                                        SVM             SMLR
             /     \          / | \                     human    animal      5  6 7  8
         |          |
        SVM        SVM
       /   \       /                   male female monkey dog
      1      2    3      4

  If it is desired to have a trailing node with a single label and thus without any classification, such as in

  > > > SVM

  > > / g1 g2

  > / 1 SVM
  >   / 2 3

  then just specify None as the classifier to use:

      TreeClassifier(SVM(),
         {'g1':  ((1,), None),
          'g2':  ((1,2,3,4), SVM())})

  Note

  Available state variables:

  - feature_ids: Feature IDS which were used for the actual training.
  - predicting_time+: Time (in seconds) which took classifier to predict
  - predictions+: Most recent set of predictions
  - trained_dataset: The dataset it has been trained on
  - trained_labels+: Set of unique labels it has been trained on
  - trained_nsamples+: Number of samples it has been trained on
  - training_confusion: Confusion matrix of learning performance
  - training_time+: Time (in seconds) which took classifier to train
  - values+: Internal classifier values the most recent predictions are based on

  (States enabled by default are listed with +)

  See also

  Please refer to the documentation of the base class for more information:

  `ProxyClassifier`

  Initialize TreeClassifier

  Parameters:

  - clf (Classifier) – Classifier to separate between the groups
  - groups (dict of meta-label: tuple of (tuple of labels, classifier)) – Defines the groups of labels and their classifiers. See `TreeClassifier` for example
  - enable_states (None or list of basestring) – Names of the state variables which should be enabled additionally to default ones
  - disable_states (None or list of basestring) – Names of the state variables which should be disabled

  `clfs` = None

    Dictionary of classifiers used by the groups

  `summary`()

    Provide summary for the TreeClassifier.

  `untrain`()

    Untrain TreeClassifier

### Navigation

- index
- next |
- previous |
- ExpPsy Project |
- NeuroDebian Project |
- PyMVPA 0.4.x Home |
- PyMVPA Home |
- Documentation »
- Module Reference »