Пример #1
0
def convert_to_phases(input_path, output_path, brain_areas, t_phases, subject):
    """
    Converts raw data into phases by Hilbert Transform

    :param input_path: path to input file
    :type input_path: str
    :param output_path: path to output directory
    :type output_path: str
    :param brain_areas: number of brain areas
    :type brain_areas: int
    :param t_phases: number of time phases
    :type t_phases: int
    :param subject: subject number
    :type subject: int
    :return: phases matrix
    :rtype: np.ndarray
    """
    phases = np.full((brain_areas, t_phases), fill_value=0).astype(np.float64)
    array = np.genfromtxt(input_path, delimiter=',')
    for area in tqdm(range(0, brain_areas)):
        # select by columns, transform to phase
        time_series = pylab.demean(signal.detrend(array[:, area]))
        phases[area, :] = np.angle(signal.hilbert(time_series))
    np.savez(os.path.join(output_path, 'phases_{}'.format(subject)), phases)
    return phases
Пример #2
0
def data2data(data, clfs, kind='svm'):
    """
    Applies all classifiers to the data and returns their output as vectors
    """
    W = array([clfs[i][0][kind] for i in range(0, len(clfs))])
    X = dot(data, W.T)
    X = demean(X, axis=1)
    return X
Пример #3
0
def normalize_signals(signals, normalization=None, axis=None, percent=None):
    # Following pylab demean:

    def matrix_subtract_along_axis(x, y, axis=0):
        "Return x minus y, where y corresponds to some statistic of x along the specified axis"
        if axis == 0 or axis is None or x.ndim <= 1:
            return x - y
        ind = [slice(None)] * x.ndim
        ind[axis] = np.newaxis
        return x - y[ind]

    def matrix_divide_along_axis(x, y, axis=0):
        "Return x divided by y, where y corresponds to some statistic of x along the specified axis"
        if axis == 0 or axis is None or x.ndim <= 1:
            return x / y
        ind = [slice(None)] * x.ndim
        ind[axis] = np.newaxis
        return x / y[ind]

    for norm, ax, prcnd in zip(ensure_list(normalization), cycle(ensure_list(axis)), cycle(ensure_list(percent))):
        if isinstance(norm, string_types):
            if isequal_string(norm, "zscore"):
                signals = zscore(signals, axis=ax)  # / 3.0
            elif isequal_string(norm, "baseline-std"):
                signals = normalize_signals(["baseline", "std"], axis=axis)
            elif norm.find("baseline") == 0 and norm.find("amplitude") >= 0:
                signals = normalize_signals(signals, ["baseline", norm.split("-")[1]], axis=axis, percent=percent)
            elif isequal_string(norm, "minmax"):
                signals = normalize_signals(signals, ["min", "max"], axis=axis)
            elif isequal_string(norm, "mean"):
                signals = demean(signals, axis=ax)
            elif isequal_string(norm, "baseline"):
                if prcnd is None:
                    prcnd = 1
                signals = matrix_subtract_along_axis(signals, np.percentile(signals, prcnd, axis=ax), axis=ax)
            elif isequal_string(norm, "min"):
                signals = matrix_subtract_along_axis(signals, np.min(signals, axis=ax), axis=ax)
            elif isequal_string(norm, "max"):
                signals = matrix_divide_along_axis(signals, np.max(signals, axis=ax), axis=ax)
            elif isequal_string(norm, "std"):
                signals = matrix_divide_along_axis(signals, signals.std(axis=ax), axis=ax)
            elif norm.find("amplitude") >= 0:
                if prcnd is None:
                    prcnd = [1, 99]
                amplitude = np.percentile(signals, prcnd[1], axis=ax) - np.percentile(signals, prcnd[0], axis=ax)
                this_ax = ax
                if isequal_string(norm.split("amplitude")[0], "max"):
                    amplitude = amplitude.max()
                    this_ax = None
                elif isequal_string(norm.split("amplitude")[0], "mean"):
                    amplitude = amplitude.mean()
                    this_ax = None
                signals = matrix_divide_along_axis(signals, amplitude, axis=this_ax)
            else:
                raise_value_error("Ignoring signals' normalization " + normalization +
                                  ",\nwhich is not one of the currently available " + str(NORMALIZATION_METHODS) + "!")
    return signals
Пример #4
0
def CreateNewPC(path2TrainingData, path2GoodData, dimensions,
                path2SavePCAData):
    trainingImg = ReadInPics(path2TrainingData, dimensions)

    # get mean and demean imagematrix
    mean = np.mean(trainingImg, axis=0)

    # demean by substract mean of all rows in matrix
    matrixDemeaned = pylab.demean(trainingImg, axis=0)

    # covariance cov = 1/(N-1) XX.T - matrix must be
    # transposed for it so samples are columns and
    # features are in rows
    cova = np.cov(matrixDemeaned.T)

    # compute eigenvalues and eigenvectors
    eigVa, eigVe = np.linalg.eig(cova)
    # sort by eigenvalues
    idx = eigVa.argsort()[::-1]
    eigVa = eigVa[idx]
    eigVe = eigVe[idx]

    assert np.all(eigVa[:-1] >= eigVa[1:])  # sorted

    # save in numpy file
    np.save('eigVe', eigVe)
    np.save(str(Path(str(path2SavePCAData), 'eigVe.npy')), eigVe)
    np.save(str(Path(str(path2SavePCAData), 'mean.npy')), mean)
    np.save(str(Path(str(path2SavePCAData), 'numberOTrainingsetImg.npy')),
            trainingImg.shape[0])

    # create new matrix of other good images to get
    # boundarys of good projected images
    goodImg = ReadInPics(path2GoodData, dimensions)

    # project on PC
    projectedGoodImg = ProjectOnPC(eigVe, goodImg, mean, dimensions)
    maxGood = np.apply_along_axis(lambda x: (max(x)), 0, projectedGoodImg)
    minGood = np.apply_along_axis(lambda x: (min(x)), 0, projectedGoodImg)

    # save max and min for good projections
    np.save(str(Path(str(path2SavePCAData), 'maxBoundary.npy')), maxGood)
    np.save(str(Path(str(path2SavePCAData), 'minBoundary.npy')), minGood)
Пример #5
0
 def center_table(self):
     self.df[self.features] = pylab.demean(self.df[self.features], axis=1)
Пример #6
0
 def center_table(self):
     return pylab.demean(self.table, axis=1)