def __init__(self, **kwargs):
_shpaldebug("Initializing.")
ClassWithCollections.__init__(self, **kwargs)
self.ndatasets = 0
self.nfeatures = 0
self.projections = None
# This option makes the roi_seed in each SL to be selected during feature selection
self.force_roi_seed = True
if self.params.nproc is not None and self.params.nproc > 1 \
and not externals.exists('pprocess'):
raise RuntimeError("The 'pprocess' module is required for "
"multiprocess searchlights. Please either "
"install python-pprocess, or reduce `nproc` "
"to 1 (got nproc=%i) or set to default None" %
self.params.nproc)
if not externals.exists('scipy'):
raise RuntimeError("The 'scipy' module is required for "
"searchlight hyperalignment.")
if self.params.results_backend == 'native':
raise NotImplementedError(
"'native' mode to handle results is still a "
"work in progress.")
#warning("results_backend is set to 'native'. This has been known"
# "to result in longer run time when working with big datasets.")
if self.params.results_backend == 'hdf5' and \
not externals.exists('h5py'):
raise RuntimeError("The 'hdf5' module is required for "
"when results_backend is set to 'hdf5'")
def __init__(self, space=None, pass_attr=None, postproc=None, **kwargs):
"""
Parameters
----------
space : str, optional
Name of the 'processing space'. The actual meaning of this argument
heavily depends on the sub-class implementation. In general, this is
a trigger that tells the node to compute and store information about
the input data that is "interesting" in the context of the
corresponding processing in the output dataset.
pass_attr : str, list of str, optional
What attribute(s) (from sa, fa, a collections, see
:meth:`Dataset.get_attr`) to pass from original dataset
provided to __call__ (before applying postproc), or from
'ca' collection of this instance (use 'ca.' prefix)
into the resultant dataset.
postproc : Node instance, optional
Node to perform post-processing of results. This node is applied
in `__call__()` to perform a final processing step on the to be
result dataset. If None, nothing is done.
"""
ClassWithCollections.__init__(self, **kwargs)
if __debug__:
debug("NO",
"Init node '%s' (space: '%s', postproc: '%s')",
(self.__class__.__name__, space, str(postproc)))
self.set_space(space)
self.set_postproc(postproc)
if isinstance(pass_attr, basestring):
pass_attr = (pass_attr,)
self.__pass_attr = pass_attr
def __init__(self, space=None, pass_attr=None, postproc=None, **kwargs):
"""
Parameters
----------
space : str, optional
Name of the 'processing space'. The actual meaning of this argument
heavily depends on the sub-class implementation. In general, this is
a trigger that tells the node to compute and store information about
the input data that is "interesting" in the context of the
corresponding processing in the output dataset.
pass_attr : str, list of str, optional
What attribute(s) (from sa, fa, a collections, see
:meth:`Dataset.get_attr`) to pass from original dataset
provided to __call__ (before applying postproc), or from
'ca' collection of this instance (use 'ca.' prefix)
into the resultant dataset.
postproc : Node instance, optional
Node to perform post-processing of results. This node is applied
in `__call__()` to perform a final processing step on the to be
result dataset. If None, nothing is done.
"""
ClassWithCollections.__init__(self, **kwargs)
if __debug__:
debug("NO", "Init node '%s' (space: '%s', postproc: '%s')",
(self.__class__.__name__, space, str(postproc)))
self.set_space(space)
self.set_postproc(postproc)
if isinstance(pass_attr, basestring):
pass_attr = (pass_attr, )
self.__pass_attr = pass_attr
def __init__(self, sd=0, distribution='rdist', fpp=None, nbins=400, **kwargs):
"""L2-Norm the values, convert them to p-values of a given distribution.
Parameters
----------
sd : int
Samples dimension (if len(x.shape)>1) on which to operate
distribution : string
Which distribution to use. Known are: 'rdist' (later normal should
be there as well)
fpp : float
At what p-value (both tails) if not None, to control for false
positives. It would iteratively prune the tails (tentative real positives)
until empirical p-value becomes less or equal to numerical.
nbins : int
Number of bins for the iterative pruning of positives
WARNING: Highly experimental/slow/etc: no theoretical grounds have been
presented in any paper, nor proven
"""
externals.exists('scipy', raise_=True)
ClassWithCollections.__init__(self, **kwargs)
self.sd = sd
if not (distribution in ['rdist']):
raise ValueError, "Actually only rdist supported at the moment" \
" got %s" % distribution
self.distribution = distribution
self.fpp = fpp
self.nbins = nbins
def __init__(self,
sd=0,
distribution='rdist',
fpp=None,
nbins=400,
**kwargs):
"""L2-Norm the values, convert them to p-values of a given distribution.
Parameters
----------
sd : int
Samples dimension (if len(x.shape)>1) on which to operate
distribution : string
Which distribution to use. Known are: 'rdist' (later normal should
be there as well)
fpp : float
At what p-value (both tails) if not None, to control for false
positives. It would iteratively prune the tails (tentative real positives)
until empirical p-value becomes less or equal to numerical.
nbins : int
Number of bins for the iterative pruning of positives
WARNING: Highly experimental/slow/etc: no theoretical grounds have been
presented in any paper, nor proven
"""
externals.exists('scipy', raise_=True)
ClassWithCollections.__init__(self, **kwargs)
self.sd = sd
if not (distribution in ['rdist']):
raise ValueError, "Actually only rdist supported at the moment" \
" got %s" % distribution
self.distribution = distribution
self.fpp = fpp
self.nbins = nbins
def __init__(self, **kwargs):
_shpaldebug("Initializing.")
ClassWithCollections.__init__(self, **kwargs)
self.ndatasets = 0
self.nfeatures = 0
self.projections = None
# This option makes the roi_seed in each SL to be selected during feature selection
self.force_roi_seed = True
if self.params.nproc is not None and self.params.nproc > 1 \
and not externals.exists('pprocess'):
raise RuntimeError("The 'pprocess' module is required for "
"multiprocess searchlights. Please either "
"install python-pprocess, or reduce `nproc` "
"to 1 (got nproc=%i) or set to default None"
% self.params.nproc)
if not externals.exists('scipy'):
raise RuntimeError("The 'scipy' module is required for "
"searchlight hyperalignment.")
if self.params.results_backend == 'native':
raise NotImplementedError("'native' mode to handle results is still a "
"work in progress.")
#warning("results_backend is set to 'native'. This has been known"
# "to result in longer run time when working with big datasets.")
if self.params.results_backend == 'hdf5' and \
not externals.exists('h5py'):
raise RuntimeError("The 'hdf5' module is required for "
"when results_backend is set to 'hdf5'")
def __init__(self, **kwargs):
ClassWithCollections.__init__(self, **kwargs)
self.commonspace = None
# mapper to a low-dimensional subspace derived using SVD on training data
# Initializing here so that call can access it without passing after train.
# Moreover, it is similar to commonspace, in that, it is required for mapping
# new subjects
self._svd_mapper = None
def __init__(self, **kwargs):
ClassWithCollections.__init__(self, **kwargs)
self.commonspace = None
# mapper to a low-dimensional subspace derived using SVD on training data
# Initializing here so that call can access it without passing after train.
# Moreover, it is similar to commonspace, in that, it is required for mapping
# new subjects
self._svd_mapper = None
def __init__(self, mode='discard', **kwargs):
"""
Parameters
----------
mode : {'discard', 'select'}
Decides whether to `select` or to `discard` features.
"""
ClassWithCollections.__init__(self, **kwargs)
self._set_mode(mode)
"""Flag whether to select or to discard elements."""
def __init__(self, mode='discard', **kwargs):
"""
Parameters
----------
mode : {'discard', 'select'}
Decides whether to `select` or to `discard` features.
"""
ClassWithCollections.__init__(self, **kwargs)
self._set_mode(mode)
"""Flag whether to select or to discard elements."""
def __init__(self, tail='both', **kwargs):
"""
Parameters
----------
tail : {'left', 'right', 'any', 'both'}
Which tail of the distribution to report. For 'any' and 'both'
it chooses the tail it belongs to based on the comparison to
p=0.5. In the case of 'any' significance is taken like in a
one-tailed test.
"""
ClassWithCollections.__init__(self, **kwargs)
self._set_tail(tail)
def __init__(self, space=None, pass_attr=None, postproc=None, **kwargs):
"""
Parameters
----------
space : str, optional
Name of the 'processing space'. The actual meaning of this argument
heavily depends on the sub-class implementation. In general, this is
a trigger that tells the node to compute and store information about
the input data that is "interesting" in the context of the
corresponding processing in the output dataset.
pass_attr : str, list of str|tuple, optional
Additional attributes to pass on to an output dataset. Attributes can
be taken from all three attribute collections of an input dataset
(sa, fa, a -- see :meth:`Dataset.get_attr`), or from the collection
of conditional attributes (ca) of a node instance. Corresponding
collection name prefixes should be used to identify attributes, e.g.
'ca.null_prob' for the conditional attribute 'null_prob', or
'fa.stats' for the feature attribute stats. In addition to a plain
attribute identifier it is possible to use a tuple to trigger more
complex operations. The first tuple element is the attribute
identifier, as described before. The second element is the name of the
target attribute collection (sa, fa, or a). The third element is the
axis number of a multidimensional array that shall be swapped with the
current first axis. The fourth element is a new name that shall be
used for an attribute in the output dataset.
Example: ('ca.null_prob', 'fa', 1, 'pvalues') will take the
conditional attribute 'null_prob' and store it as a feature attribute
'pvalues', while swapping the first and second axes. Simplified
instructions can be given by leaving out consecutive tuple elements
starting from the end.
postproc : Node instance, optional
Node to perform post-processing of results. This node is applied
in `__call__()` to perform a final processing step on the to be
result dataset. If None, nothing is done.
"""
ClassWithCollections.__init__(self, **kwargs)
if __debug__:
debug("NO",
"Init node '%s' (space: '%s', postproc: '%s')",
(self.__class__.__name__, space, str(postproc)))
self.set_space(space)
self.set_postproc(postproc)
if isinstance(pass_attr, basestring):
pass_attr = (pass_attr,)
self.__pass_attr = pass_attr
def __init__(self, space=None, pass_attr=None, postproc=None, **kwargs):
"""
Parameters
----------
space : str, optional
Name of the 'processing space'. The actual meaning of this argument
heavily depends on the sub-class implementation. In general, this is
a trigger that tells the node to compute and store information about
the input data that is "interesting" in the context of the
corresponding processing in the output dataset.
pass_attr : str, list of str|tuple, optional
Additional attributes to pass on to an output dataset. Attributes can
be taken from all three attribute collections of an input dataset
(sa, fa, a -- see :meth:`Dataset.get_attr`), or from the collection
of conditional attributes (ca) of a node instance. Corresponding
collection name prefixes should be used to identify attributes, e.g.
'ca.null_prob' for the conditional attribute 'null_prob', or
'fa.stats' for the feature attribute stats. In addition to a plain
attribute identifier it is possible to use a tuple to trigger more
complex operations. The first tuple element is the attribute
identifier, as described before. The second element is the name of the
target attribute collection (sa, fa, or a). The third element is the
axis number of a multidimensional array that shall be swapped with the
current first axis. The fourth element is a new name that shall be
used for an attribute in the output dataset.
Example: ('ca.null_prob', 'fa', 1, 'pvalues') will take the
conditional attribute 'null_prob' and store it as a feature attribute
'pvalues', while swapping the first and second axes. Simplified
instructions can be given by leaving out consecutive tuple elements
starting from the end.
postproc : Node instance, optional
Node to perform post-processing of results. This node is applied
in `__call__()` to perform a final processing step on the to be
result dataset. If None, nothing is done.
"""
ClassWithCollections.__init__(self, **kwargs)
if __debug__:
debug("NO",
"Init node '%s' (space: '%s', postproc: '%s')",
(self.__class__.__name__, space, str(postproc)))
self.set_space(space)
self.set_postproc(postproc)
if isinstance(pass_attr, basestring):
pass_attr = (pass_attr,)
self.__pass_attr = pass_attr
def __init__(self, space=None, postproc=None, **kwargs):
"""
Parameters
----------
space: str, optional
Name of the 'processing space'. The actual meaning of this argument
heavily depends on the sub-class implementation. In general, this is
a trigger that tells the node to compute and store information about
the input data that is "interesting" in the context of the
corresponding processing in the output dataset.
postproc : Node instance, optional
Node to perform post-processing of results. This node is applied
in `__call__()` to perform a final processing step on the to be
result dataset. If None, nothing is done.
"""
ClassWithCollections.__init__(self, **kwargs)
self.set_space(space)
self.set_postproc(postproc)
def __init__(self, space=None, postproc=None, **kwargs):
"""
Parameters
----------
space: str, optional
Name of the 'processing space'. The actual meaning of this argument
heavily depends on the sub-class implementation. In general, this is
a trigger that tells the node to compute and store information about
the input data that is "interesting" in the context of the
corresponding processing in the output dataset.
postproc : Node instance, optional
Node to perform post-processing of results. This node is applied
in `__call__()` to perform a final processing step on the to be
result dataset. If None, nothing is done.
"""
ClassWithCollections.__init__(self, **kwargs)
if __debug__:
debug("NO", "Init node '%s' (space: '%s', postproc: '%s')",
(self.__class__.__name__, space, str(postproc)))
self.set_space(space)
self.set_postproc(postproc)
def __init__(self, **kwargs):
ClassWithCollections.__init__(self, **kwargs)
def __init__(self, **kwargs):
# XXX make such example when we actually need to invoke
# constructor
# TestClassProper.__init__(self, **kwargs)
ClassWithCollections.__init__(self, **kwargs)
def __init__(self, **kwargs):
ClassWithCollections.__init__(self, **kwargs)
self.commonspace = None
def __init__(self, **kwargs):
# XXX make such example when we actually need to invoke
# constructor
# TestClassProper.__init__(self, **kwargs)
ClassWithCollections.__init__(self, **kwargs)
def __init__(self, *args, **kwargs):
"""Base Kernel class has no parameters
"""
ClassWithCollections.__init__(self, *args, **kwargs)
self._k = None
"""Implementation specific version of the kernel"""
def __init__(self, *args, **kwargs):
"""Base Kernel class has no parameters
"""
ClassWithCollections.__init__(self, *args, **kwargs)
self._k = None
"""Implementation specific version of the kernel"""
def __init__(self, **kwargs):
ClassWithCollections.__init__(self, **kwargs)
self.commonspace = None
