def fit(self, epochs):
self.picks = _handle_picks(info=epochs.info, picks=self.picks)
_check_data(epochs, picks=self.picks,
ch_constraint='single_channel_type', verbose=self.verbose)
self.ch_type = _get_channel_type(epochs, self.picks)
n_epochs = len(epochs)
self.ch_subsets_ = self._get_random_subsets(epochs.info)
self.mappings_ = self._get_mappings(epochs)
n_jobs = check_n_jobs(self.n_jobs)
parallel = Parallel(n_jobs, verbose=10)
my_iterator = delayed(_iterate_epochs)
if self.verbose is not False and self.n_jobs > 1:
print('Iterating epochs ...')
verbose = False if self.n_jobs > 1 else self.verbose
corrs = parallel(my_iterator(self, epochs, idxs, verbose)
for idxs in np.array_split(np.arange(n_epochs),
n_jobs))
self.corr_ = np.concatenate(corrs)
if self.verbose is not False and self.n_jobs > 1:
print('[Done]')
# compute how many windows is a sensor RANSAC-bad
self.bad_log = np.zeros_like(self.corr_)
self.bad_log[self.corr_ < self.min_corr] = 1
bad_log = self.bad_log.sum(axis=0)
bad_idx = np.where(bad_log > self.unbroken_time * n_epochs)[0]
if len(bad_idx) > 0:
self.bad_chs_ = [
epochs.info['ch_names'][self.picks[p]] for p in bad_idx]
else:
self.bad_chs_ = []
return self
def fit(self, epochs):
_check_data(epochs)
self.ch_type = _get_channel_type(epochs)
n_epochs = len(epochs)
self.ch_subsets_ = self._get_random_subsets(epochs.info)
self.mappings_ = self._get_mappings(epochs)
n_jobs = check_n_jobs(self.n_jobs)
parallel = Parallel(n_jobs, verbose=10)
my_iterator = delayed(_iterate_epochs)
if self.verbose is not False and self.n_jobs > 1:
print('Iterating epochs ...')
verbose = False if self.n_jobs > 1 else self.verbose
corrs = parallel(
my_iterator(self, epochs, idxs, verbose)
for idxs in np.array_split(np.arange(n_epochs), n_jobs))
self.corr_ = np.concatenate(corrs)
if self.verbose is not False and self.n_jobs > 1:
print('[Done]')
# compute how many windows is a sensor RANSAC-bad
self.bad_log = np.zeros_like(self.corr_)
self.bad_log[self.corr_ < self.min_corr] = 1
bad_log = self.bad_log.sum(axis=0)
bad_idx = np.where(bad_log > self.unbroken_time * n_epochs)[0]
if len(bad_idx) > 0:
self.bad_chs_ = [epochs.info['ch_names'][p] for p in bad_idx]
else:
self.bad_chs_ = []
return self
def fit(self,
raw: mne.io.RawArray,
start: float = None,
stop: float = None,
reject_by_annotation: bool = True,
gfp: bool = False,
n_jobs: int = 1,
verbose=None) -> mod_Kmeans:
"""[summary]
Args:
raw (mne.io.RawArray): [description]
start (float, optional): [description]. Defaults to None.
stop (float, optional): [description]. Defaults to None.
reject_by_annotation (bool, optional): [description]. Defaults to True.
gfp (bool, optional): [description]. Defaults to False.
n_jobs (int, optional): [description]. Defaults to 1.
verbose ([type], optional): [description]. Defaults to None.
Returns:
mod_Kmeans: [description]
"""
_validate_type(raw, (BaseRaw), 'raw', 'Raw')
reject_by_annotation = 'omit' if reject_by_annotation else None
start, stop = _check_start_stop(raw, start, stop)
n_jobs = check_n_jobs(n_jobs)
if len(raw.info['bads']) is not 0:
warn('Bad channels are present in the recording. '
'They will still be used to compute microstate topographies. '
'Consider using Raw.pick() or Raw.interpolate_bads()'
' before fitting.')
data = raw.get_data(start,
stop,
reject_by_annotation=reject_by_annotation)
if gfp is True:
data = _extract_gfps(data)
best_gev = 0
if n_jobs == 1:
for _ in range(self.n_init):
gev, maps, segmentation = self._run_mod_kmeans(data)
if gev > best_gev:
best_gev, best_maps, best_segmentation = gev, maps, segmentation
else:
parallel, p_fun, _ = parallel_func(self._run_mod_kmeans,
total=self.n_init,
n_jobs=n_jobs)
runs = parallel(p_fun(data) for i in range(self.n_init))
runs = np.array(runs)
best_run = np.argmax(runs[:, 0])
best_gev, best_maps, best_segmentation = runs[best_run]
self.cluster_centers = best_maps
self.GEV = best_gev
self.labels = best_segmentation
self.current_fit = True
return (self)
def _parallel_scorer(y_true, y_pred, func, n_jobs=1):
from nose.tools import assert_true
from mne.parallel import parallel_func, check_n_jobs
# check dimensionality
assert_true(y_true.ndim == 1)
assert_true(y_pred.ndim == 2)
# set jobs not > to n_chunk
n_jobs = min(y_pred.shape[1], check_n_jobs(n_jobs))
parallel, p_func, n_jobs = parallel_func(func, n_jobs)
chunks = np.array_split(y_pred.transpose(), n_jobs)
# run parallel
out = parallel(p_func(chunk.T, y_true) for chunk in chunks)
# gather data
return np.concatenate(out, axis=0)
def fit(self, epochs):
self.picks = _handle_picks(info=epochs.info, picks=self.picks)
_check_data(epochs,
picks=self.picks,
ch_constraint='single_channel_type',
verbose=self.verbose)
self.ch_type = _get_channel_type(epochs, self.picks)
n_epochs = len(epochs)
n_jobs = check_n_jobs(self.n_jobs)
parallel = Parallel(n_jobs, verbose=10)
my_iterator = delayed(_iterate_epochs)
if self.verbose is not False and self.n_jobs > 1:
print('Iterating epochs ...')
verbose = False if self.n_jobs > 1 else self.verbose
rng = check_random_state(self.random_state)
base_random_state = rng.randint(np.iinfo(np.int16).max)
self.ch_subsets_ = [
self._get_random_subsets(epochs.info,
base_random_state + random_state)
for random_state in np.arange(0, n_epochs, n_jobs)
]
epoch_idxs = np.array_split(np.arange(n_epochs), n_jobs)
corrs = parallel(
my_iterator(self, epochs, idxs, chs, verbose)
for idxs, chs in zip(epoch_idxs, self.ch_subsets_))
self.corr_ = np.concatenate(corrs)
if self.verbose is not False and self.n_jobs > 1:
print('[Done]')
# compute how many windows is a sensor RANSAC-bad
self.bad_log = np.zeros_like(self.corr_)
self.bad_log[self.corr_ < self.min_corr] = 1
bad_log = self.bad_log.sum(axis=0)
bad_idx = np.where(bad_log > self.unbroken_time * n_epochs)[0]
if len(bad_idx) > 0:
self.bad_chs_ = [
epochs.info['ch_names'][self.picks[p]] for p in bad_idx
]
else:
self.bad_chs_ = []
return self
def __init__(self, estimator=None, n_jobs=-1):
from mne.parallel import check_n_jobs
from sklearn.linear_model import LinearRegression
self.estimator = LinearRegression() if estimator is None else estimator
self.n_jobs = n_jobs = check_n_jobs(n_jobs)
def make_pert_forward_solution(info,
trans,
src,
bem,
perts,
meg=True,
eeg=True,
mindist=0.0,
ignore_ref=False,
n_jobs=1,
verbose=None):
"""Calculate a forward solution for a subject.
Parameters
----------
info : instance of mne.Info | str
If str, then it should be a filename to a Raw, Epochs, or Evoked
file with measurement information. If dict, should be an info
dict (such as one from Raw, Epochs, or Evoked).
trans : dict | str | None
Either a transformation filename (usually made using mne_analyze)
or an info dict (usually opened using read_trans()).
If string, an ending of `.fif` or `.fif.gz` will be assumed to
be in FIF format, any other ending will be assumed to be a text
file with a 4x4 transformation matrix (like the `--trans` MNE-C
option). Can be None to use the identity transform.
src : str | instance of SourceSpaces
If string, should be a source space filename. Can also be an
instance of loaded or generated SourceSpaces.
bem : dict | str
Filename of the BEM (e.g., "sample-5120-5120-5120-bem-sol.fif") to
use, or a loaded sphere model (dict).
meg : bool
If True (Default), include MEG computations.
eeg : bool
If True (Default), include EEG computations.
mindist : float
Minimum distance of sources from inner skull surface (in mm).
ignore_ref : bool
If True, do not include reference channels in compensation. This
option should be True for KIT files, since forward computation
with reference channels is not currently supported.
n_jobs : int
Number of jobs to run in parallel.
perts : dict
A dictionary containing perturbation parameters for gradiometer
imbalance, sensor miscalibration, and misalignment
verbose : bool, str, int, or None
If not None, override default verbose level (see :func:`mne.verbose`
and :ref:`Logging documentation <tut_logging>` for more).
Returns
-------
fwd : instance of Forward
The forward solution.
See Also
--------
convert_forward_solution
Notes
-----
The ``--grad`` option from MNE-C (to compute gradients) is not implemented
here.
To create a fixed-orientation forward solution, use this function
followed by :func:`mne.convert_forward_solution`.
"""
# Currently not (sup)ported:
# 1. --grad option (gradients of the field, not used much)
# 2. --fixed option (can be computed post-hoc)
# 3. --mricoord option (probably not necessary)
# read the transformation from MRI to HEAD coordinates
# (could also be HEAD to MRI)
mri_head_t, trans = _get_trans(trans)
if isinstance(bem, ConductorModel):
bem_extra = 'instance of ConductorModel'
else:
bem_extra = bem
if not isinstance(info, (Info, string_types)):
raise TypeError('info should be an instance of Info or string')
if isinstance(info, string_types):
info_extra = op.split(info)[1]
info = read_info(info, verbose=False)
else:
info_extra = 'instance of Info'
n_jobs = check_n_jobs(n_jobs)
# Report the setup
logger.info('Source space : %s' % src)
logger.info('MRI -> head transform : %s' % trans)
logger.info('Measurement data : %s' % info_extra)
if isinstance(bem, ConductorModel) and bem['is_sphere']:
logger.info('Sphere model : origin at %s mm' % (bem['r0'], ))
logger.info('Standard field computations')
else:
logger.info('Conductor model : %s' % bem_extra)
logger.info('Accurate field computations')
logger.info('Do computations in %s coordinates',
_coord_frame_name(FIFF.FIFFV_COORD_HEAD))
logger.info('Free source orientations')
megcoils, meg_info, compcoils, megnames, eegels, eegnames, rr, info, \
update_kwargs, bem = _prepare_for_forward(
src, mri_head_t, info, bem, mindist, n_jobs, perts, bem_extra, trans,
info_extra, meg, eeg, ignore_ref)
del (src, mri_head_t, trans, info_extra, bem_extra, mindist, meg, eeg,
ignore_ref)
# Time to do the heavy lifting: MEG first, then EEG
coil_types = ['meg', 'eeg']
coils = [megcoils, eegels]
ccoils = [compcoils, None]
infos = [meg_info, None]
megfwd, eegfwd = _compute_forwards(rr, bem, coils, ccoils, infos,
coil_types, n_jobs)
# merge forwards
fwd = _merge_meg_eeg_fwds(_to_forward_dict(megfwd, megnames),
_to_forward_dict(eegfwd, eegnames),
verbose=False)
logger.info('')
# Don't transform the source spaces back into MRI coordinates (which is
# done in the C code) because mne-python assumes forward solution source
# spaces are in head coords.
fwd.update(**update_kwargs)
logger.info('Finished.')
return fwd
def __init__(self, estimator=None, n_jobs=-1):
from mne.parallel import check_n_jobs
from sklearn.linear_model import LinearRegression
self.estimator = LinearRegression() if estimator is None else estimator
self.n_jobs = n_jobs = check_n_jobs(n_jobs)
def _permutation_cluster_test_AT(X, threshold, tail, n_permutations,
connectivity, n_jobs, seed, max_step, exclude,
step_down_p, t_power, out_type,
check_disjoint, buffer_size):
n_jobs = check_n_jobs(n_jobs)
"""Aux Function.
Note. X is required to be a list. Depending on the length of X
either a 1 sample t-test or an F test / more sample permutation scheme
is elicited.
"""
if out_type not in ['mask', 'indices']:
raise ValueError('out_type must be either \'mask\' or \'indices\'')
if not isinstance(threshold, dict) and (tail < 0 and threshold > 0
or tail > 0 and threshold < 0
or tail == 0 and threshold < 0):
raise ValueError(
'incompatible tail and threshold signs, got %s and %s' %
(tail, threshold))
# check dimensions for each group in X (a list at this stage).
X = [x[:, np.newaxis] if x.ndim == 1 else x for x in X]
n_times = X[0].shape[0]
sample_shape = X[0].shape[1:]
for x in X:
if x.shape[1:] != sample_shape:
raise ValueError('All samples mush have the same size')
# # flatten the last dimensions in case the data is high dimensional
# X = [np.reshape(x, (x.shape[0], -1)) for x in X]
n_tests = X[0].shape[1]
if connectivity is not None and connectivity is not False:
connectivity = cluster_level._setup_connectivity(
connectivity, n_tests, n_times)
if (exclude is not None) and not exclude.size == n_tests:
raise ValueError('exclude must be the same shape as X[0]')
# determine if connectivity itself can be separated into disjoint sets
if check_disjoint is True and (connectivity is not None
and connectivity is not False):
partitions = cluster_level._get_partitions_from_connectivity(
connectivity, n_times)
else:
partitions = None
max_clu_lens = np.zeros(n_permutations)
for i in range(0, n_permutations):
#logger.info('Running initial clustering')
include = None
out = cluster_level._find_clusters(X[i][0],
threshold,
tail,
connectivity,
max_step=max_step,
include=include,
partitions=partitions,
t_power=t_power,
show_info=True)
clusters, cluster_stats = out
logger.info('Found %d clusters' % len(clusters))
# convert clusters to old format
if connectivity is not None and connectivity is not False:
# our algorithms output lists of indices by default
if out_type == 'mask':
clusters = cluster_level._cluster_indices_to_mask(
clusters, n_tests)
else:
# ndimage outputs slices or boolean masks by default
if out_type == 'indices':
clusters = cluster_level._cluster_mask_to_indices(clusters)
# The clusters should have the same shape as the samples
clusters = cluster_level._reshape_clusters(clusters, sample_shape)
max_clu_len = 0
for j in range(0, len(clusters)):
max_new = len(clusters[j][0])
if max_new > max_clu_len:
max_clu_len = max_new
logger.info('Max cluster length %d' % max_clu_len)
max_clu_lens[i] = max_clu_len
return max_clu_lens, clusters