Beispiel #1
0
def get_window(master: EpochsArray, config, start):
    fps = config['fps']

    end = start + config['window_duration'] - 1. / fps

    window = master.copy().crop(start, end)

    return window
Beispiel #2
0
def test_decim():
    """Test evoked decimation."""
    rng = np.random.RandomState(0)
    n_epochs, n_channels, n_times = 5, 10, 20
    dec_1, dec_2 = 2, 3
    decim = dec_1 * dec_2
    sfreq = 1000.
    sfreq_new = sfreq / decim
    data = rng.randn(n_epochs, n_channels, n_times)
    events = np.array([np.arange(n_epochs), [0] * n_epochs, [1] * n_epochs]).T
    info = create_info(n_channels, sfreq, 'eeg')
    info['lowpass'] = sfreq_new / float(decim)
    epochs = EpochsArray(data, info, events)
    data_epochs = epochs.copy().decimate(decim).get_data()
    data_epochs_2 = epochs.copy().decimate(decim, offset=1).get_data()
    data_epochs_3 = epochs.decimate(dec_1).decimate(dec_2).get_data()
    assert_array_equal(data_epochs, data[:, :, ::decim])
    assert_array_equal(data_epochs_2, data[:, :, 1::decim])
    assert_array_equal(data_epochs, data_epochs_3)

    # Now let's do it with some real data
    raw = read_raw_fif(raw_fname, add_eeg_ref=False)
    events = read_events(event_name)
    sfreq_new = raw.info['sfreq'] / decim
    raw.info['lowpass'] = sfreq_new / 4.  # suppress aliasing warnings
    picks = pick_types(raw.info, meg=True, eeg=True, exclude=())
    epochs = Epochs(raw, events, 1, -0.2, 0.5, picks=picks, preload=True,
                    add_eeg_ref=False)
    for offset in (0, 1):
        ev_ep_decim = epochs.copy().decimate(decim, offset).average()
        ev_decim = epochs.average().decimate(decim, offset)
        expected_times = epochs.times[offset::decim]
        assert_allclose(ev_decim.times, expected_times)
        assert_allclose(ev_ep_decim.times, expected_times)
        expected_data = epochs.get_data()[:, :, offset::decim].mean(axis=0)
        assert_allclose(ev_decim.data, expected_data)
        assert_allclose(ev_ep_decim.data, expected_data)
        assert_equal(ev_decim.info['sfreq'], sfreq_new)
        assert_array_equal(ev_decim.times, expected_times)
Beispiel #3
0
def _compute_fold(metric_fx,
                  targets,
                  train,
                  test,
                  epoch,
                  cv_normalize_noise=None,
                  mean_groups=False,
                  time_diag_only=False):
    """
    Computes pairwise metric across time for one fold

    Arguments
    ---------
    metric_fx : either an allowed string (e.g., 'correlation') or an object
        with attributes 'fit' and 'score' (similar to scikit-learn estimators)
    targets : array (n_trials,)
        target (condition) for each trials; they must be integers
    train : array-like of int
        indices of the training data
    test : array-like of int
        indices of the testing data
    epoch : instance of mne.Epoch
    cv_normalize_noise : str | None (default None)
        Multivariately normalize the trials before applying the metric
        (distance or classification). Normalization is performed with
        cross-validation, that is the covariance matrix is estimated in the
        training set, and then applied to the test set. Normalization is
        always performed on single trials, thus before averaging within each
        class if `mean_groups` is set to True.
        Valid values for `cv_normalize_noise` are 'epoch' | 'baseline' | None:
            - 'epoch' computes the covariance matrix on the entire epoch;
            - 'baseline' uses only the baseline condition; it requires `epoch`
            to have a valid baseline (i.e., to have performed baseline
            correction)
    mean_groups : bool (default False)
        Whether the trials belonging to each target should be averaged prior
        to running the metric. This is useful if the metric is a distance
        metric. Should be set to False for classification.
    time_diag_only : bool (default False)
        Whether to run only for the diagonal in time,
        e.g. for train_time == test_time

    Returns
    -------
    rdms: array (n_pairwise_targets, n_pairwise_times)
        the cross-validated RDM over time
    targets_pairs : list of len n_pairwise_targets
        the labels corresponding to each element in rdms
    """

    targets = np.asarray(targets)
    if targets.dtype != np.dtype('int64'):
        raise ValueError("targets must be integers, "
                         "not {0}".format(targets.dtype))

    # impose conditions in epoch as targets, so that covariance
    # matrix is computed within each target
    events_ = epoch.events.copy()
    events_[:, 2] = targets
    epoch_ = EpochsArray(epoch.get_data(),
                         info=epoch.info,
                         events=events_,
                         tmin=epoch.times[0])
    epoch_.baseline = epoch.baseline

    # get training and testing data
    epoch_train = epoch_.copy()[train]
    targets_train = targets[train]
    assert (len(epoch_train) == len(targets_train))
    epoch_test = epoch_.copy()[test]
    targets_test = targets[test]
    assert (len(epoch_test) == len(targets_test))

    # perform multi variate noise normalization
    epoch_train, epoch_test = _multiv_normalize(epoch_train, epoch_test,
                                                cv_normalize_noise)
    if mean_groups:
        # average within train and test for each target
        epoch_train, targets_train = mean_group(epoch_train, targets_train)
        epoch_test, targets_test = mean_group(epoch_test, targets_test)
        # the targets should be the same in both training and testing
        # set or else we are correlating weird things together
        assert_array_equal(targets_train, targets_test)
    rdms = _run_metric(metric_fx,
                       epoch_train,
                       targets_train,
                       epoch_test,
                       targets_test,
                       time_diag_only=time_diag_only)

    # return also the pairs labels. since we are taking triu, we loop first
    # across rows
    unique_targets = _get_unique_targets(targets_train, targets_test)
    targets_pairs = []
    for tr_lbl, te_lbl in _get_combinations_triu(unique_targets):
        targets_pairs.append('+'.join(map(str, [tr_lbl, te_lbl])))

    return rdms, targets_pairs