def get_psi_entropies(data): bands = [0.5, 4, 7, 12, 30, 100] fs = 125 array_length = 1024 cols = data.shape[1] rows = math.floor(data.shape[0] / array_length) alpha_psi_entropies = pd.DataFrame([]) temp_data = pd.DataFrame() for x in range(cols): alpha_psis = [] entropies = [] temp_col_alpha = 'alpha_psi ' + str(x) temp_col_entropy = 'spectral_entropy ' + str(x) for y in range(rows): psis, power_ratios = bin_power( data.iloc[(y * array_length):((y + 1) * array_length), x], bands, fs) alpha_psis.append(psis[2]) spec_entropies = spectral_entropy( data.iloc[(y * array_length):((y + 1) * array_length), x], bands, fs, power_ratios) entropies.append(spec_entropies) temp_data[temp_col_alpha] = alpha_psis temp_data[temp_col_entropy] = entropies alpha_psi_entropies = alpha_psi_entropies.append(temp_data, ignore_index=True) return alpha_psi_entropies
def SpectralEntropy(self): b = pyeeg.bin_power(self.channel_data,self.bands,self.samplingFrequency) resp = pyeeg.spectral_entropy(self.channel_data,self.bands,self.samplingFrequency,Power_Ratio=b) resp = [0 if math.isnan(x) else x for x in resp] label = 'SpectralEntropy_' labels = label+pd.Series(range(len(resp)),dtype=str) return [np.array(resp),labels.values]
def get_psi_entropies(data): # Setting variables needed for for loop band = [0.5, 4, 7, 12, 30, 100] fs = 1024 size = 1024 columns = data.shape[1] rows = math.floor(data.shape[0] / size) alpha_psi_df = pd.DataFrame([]) temp_data = pd.DataFrame([]) # Creating for loop for x in range(columns): alpha_psis = [] entropies = [] temp_col_alpha = 'alpha_psi ' + str(x) temp_col_entropy = 'spectral_entropy ' + str(x) for y in range(rows): psis, power_ratios = bin_power(data.iloc[(y * size):((y + 1) * size), x], band, fs) alpha_psis.append(psis[2]) spec_entropies = spectral_entropy(data.iloc[(y * size):((y + 1) * size), x], band, fs, power_ratios) entropies.append(spec_entropies) temp_data[temp_col_alpha] = alpha_psis temp_data[temp_col_entropy] = entropies alpha_psi_df = alpha_psi_df.append(temp_data, ignore_index = True) return alpha_psi_df
def set_spectral_entropy(self): for e in xrange(self.data.shape[0]): if np.all(self.data[e][:1000] == 0): continue name = 'spectral_entropy_e' + str(e) pr = self.power_ratio['power_ratio_e' + str(e)] value = pyeeg.spectral_entropy(self.data[e], range(len(pr)), int(self.frequency), pr) self.features[name] = value
def mean_spectral_entropy(data): psd_vals = all_psd(data) power_ratio = [] sum_psd_vals = sum_psd(data) for val in psd_vals: power_ratio.append(val / sum_psd_vals) bands = [0, 4, 8, 12, 30, 45] Fs = 256 spec_entropy = p.spectral_entropy(data, bands, Fs, power_ratio) return spec_entropy
def single_window_q_features(eeg_window, samplerate): ''' Calculates all the features for the provided eeg sample data. Data should be an ndarray with ''' features = [] # Calculate spectral entropy bins = [0.1, 4, 8, 12, 30, 70, 180] spec_entropies = pyeeg.spectral_entropy(eeg_window, bins, samplerate)
def SpectralEntropy(x): fs = 128 band = [1, 4, 8, 12, 30] b = pyeeg.bin_power(x, band, fs) resp = pyeeg.spectral_entropy(x, band, fs, Power_Ratio=b) resp = [0 if math.isnan(x) else x for x in resp] return resp
def SpectralEntropy(self): b = pyeeg.bin_power(self.channel_data, self.bands, self.samplingFrequency) resp = pyeeg.spectral_entropy(self.channel_data, self.bands, self.samplingFrequency, Power_Ratio=b) resp = [0 if math.isnan(x) else x for x in resp] label = 'SpectralEntropy_' labels = label + pd.Series(range(len(resp)), dtype=str) return [np.array(resp), labels.values]
def features(mat): Kmax = 5 Tau = 4 DE = 10 M = 10 R = 0.3 Band = np.arange(1, 86) Fs = 173 DFA = pyeeg.dfa(mat) HFD = pyeeg.hfd(mat, Kmax) SVD_Entropy = pyeeg.svd_entropy(mat, Tau, DE) Fisher_Information = pyeeg.fisher_info(mat, Tau, DE) #ApEn = pyeeg.ap_entropy(mat, M, R) # very slow PFD = pyeeg.pfd(mat) Spectral_Entropy = pyeeg.spectral_entropy(mat, Band, Fs, Power_Ratio=None) sleep(0.01) return (DFA, HFD, SVD_Entropy, Fisher_Information, PFD, Spectral_Entropy)
def get_features(signal): #print(signal) freq_cutoffs = [3, 8, 12, 27, 50] features = [] features.append(rms(signal)) s = lpf(signal, SAMPLING_RATE, freq_cutoffs[0]) features.append(rms(s)) for i in range(len(freq_cutoffs) - 1): s = bp(signal, SAMPLING_RATE, freq_cutoffs[i], freq_cutoffs[i + 1]) features.append(rms(s)) fourier = np.fft.rfft(signal * np.hamming(signal.size)) features.extend(abs(fourier)) wsize = 64 X = mne.time_frequency.stft(signal, wsize, verbose=False) freqs = np.reshape(abs(X), X.size) features.extend(freqs) features.append(pyeeg.hurst(signal)) features.append(pyeeg.hfd(signal, 10)) e = pyeeg.spectral_entropy(signal, np.append(0.5, freq_cutoffs), SAMPLING_RATE) features.append(e) features.extend(pyeeg.hjorth(signal)) features.append(pyeeg.pfd(signal)) features.append(pyeeg.mean(signal)) features.append(scipy.stats.skew(signal)) features.append(scipy.stats.kurtosis(signal)) #features.extend(signal) return features
def get_features(signal): #print(signal) freq_cutoffs = [3, 8, 12, 27, 50] features = [] features.append(rms(signal)) s = lpf(signal, SAMPLING_RATE, freq_cutoffs[0]) features.append(rms(s)) for i in range(len(freq_cutoffs)-1): s = bp(signal, SAMPLING_RATE, freq_cutoffs[i], freq_cutoffs[i+1]) features.append(rms(s)) fourier = np.fft.rfft(signal * np.hamming(signal.size)) features.extend(abs(fourier)) wsize = 64 X = mne.time_frequency.stft(signal, wsize, verbose=False) freqs = np.reshape(abs(X), X.size) features.extend(freqs) features.append(pyeeg.hurst(signal)) features.append(pyeeg.hfd(signal, 10)) e = pyeeg.spectral_entropy(signal, np.append(0.5, freq_cutoffs), SAMPLING_RATE) features.append(e) features.extend(pyeeg.hjorth(signal)) features.append(pyeeg.pfd(signal)) features.append(pyeeg.mean(signal)) features.append(scipy.stats.skew(signal)) features.append(scipy.stats.kurtosis(signal)) #features.extend(signal) return features
def eeg_features(data): data = np.asarray(data) res = np.zeros([22]) Kmax = 5 # M = 10 # R = 0.3 Band = [1, 5, 10, 15, 20, 25] Fs = 256 power, power_ratio = pyeeg.bin_power(data, Band, Fs) f, P = welch(data, fs=Fs, window='hanning', noverlap=0, nfft=int(256.)) # Signal power spectrum area_freq = cumtrapz(P, f, initial=0) res[0] = np.sqrt(np.sum(np.power(data, 2)) / data.shape[0]) # amplitude RMS res[1] = statistics.stdev(data)**2 # variance res[2] = kurtosis(data) # kurtosis res[3] = skew(data) # skewness res[4] = max(data) # max amplitude res[5] = min(data) # min amplitude res[6] = len(argrelextrema( data, np.greater)[0]) # number of local extrema or peaks res[7] = ((data[:-1] * data[1:]) < 0).sum() # number of zero crossings res[8] = pyeeg.hfd(data, Kmax) # Higuchi Fractal Dimension res[9] = pyeeg.pfd(data) # Petrosian Fractal Dimension res[10] = pyeeg.hurst(data) # Hurst exponent res[11] = pyeeg.spectral_entropy( data, Band, Fs, Power_Ratio=power_ratio) # spectral entropy (1.21s) res[12] = area_freq[-1] # total power res[13] = f[np.where(area_freq >= res[12] / 2)[0][0]] # median frequency res[14] = f[np.argmax(P)] # peak frequency res[15], res[16] = pyeeg.hjorth(data) # Hjorth mobility and complexity res[17] = power_ratio[0] res[18] = power_ratio[1] res[19] = power_ratio[2] res[20] = power_ratio[3] res[21] = power_ratio[4] # res[22] = pyeeg.samp_entropy(data, M, R) # sample entropy # res[23] = pyeeg.ap_entropy(data, M, R) # approximate entropy (1.14s) return (res)
def feature_wave(self, toolName=None, Fs=256): if (toolName == None): print('please select a tool') return if toolName in self.FeatureSet.dict[0]: index = self.FeatureSet.dict[0][toolName] else: index = -1 print(toolName) if toolName == 'DWT': answer_train = DWT(self.DataSet.trainSet_data[0], 'db4') answer_test = DWT(self.DataSet.testSet_data[0], 'db4') print('DWT feature extraction succeed db4') elif toolName == 'hurst': answer_train = [ pyeeg.hurst(i) for i in self.DataSet.trainSet_data[0] ] answer_test = [ pyeeg.hurst(i) for i in self.DataSet.testSet_data[0] ] print('hurst feature extraction succeed') elif toolName == 'dfa': answer_train = [ pyeeg.dfa(i, L=[4, 8, 16, 32, 64]) for i in self.DataSet.trainSet_data[0] ] answer_test = [ pyeeg.dfa(i, L=[4, 8, 16, 32, 64]) for i in self.DataSet.testSet_data[0] ] print('dfa feature extraction succeed') elif toolName == 'fisher_info': answer_train = [ pyeeg.fisher_info(i, 2, 20) for i in self.DataSet.trainSet_data[0] ] answer_test = [ pyeeg.fisher_info(i, 2, 20) for i in self.DataSet.testSet_data[0] ] print('fisher_info feature extraction succeed') elif toolName == 'svd_entropy': answer_train = [ pyeeg.svd_entropy(i, 2, 20) for i in self.DataSet.trainSet_data[0] ] answer_test = [ pyeeg.svd_entropy(i, 2, 20) for i in self.DataSet.testSet_data[0] ] print('svd_entropy feature extraction succeed') elif toolName == 'spectral_entropy': bandlist = [0.5, 4, 7, 12, 30, 100] answer_train = [ pyeeg.spectral_entropy(i, bandlist, Fs) for i in self.DataSet.trainSet_data[0] ] answer_test = [ pyeeg.spectral_entropy(i, bandlist, Fs) for i in self.DataSet.testSet_data[0] ] print('spectral_entropy feature extraction succeed') elif toolName == 'hjorth': # 得到两个量 第一个是 mobility 第二个是 complexity answer_train = [ pyeeg.hjorth(i) for i in self.DataSet.trainSet_data[0] ] answer_test = [ pyeeg.hjorth(i) for i in self.DataSet.testSet_data[0] ] answer_train = np.array(answer_train) answer_test = np.array(answer_test) for i in answer_train: i[1] = i[1] / 100 for i in answer_test: i[1] = i[1] / 100 #只取Mobility answer_train = np.array(answer_train[:, 0]) answer_test = np.array(answer_test[:, 0]) print('hjorth feature extraction succeed') elif toolName == 'hfd': answer_train = [ pyeeg.hfd(i, 8) for i in self.DataSet.trainSet_data[0] ] answer_test = [ pyeeg.hfd(i, 8) for i in self.DataSet.testSet_data[0] ] print('hfd feature extraction succeed') elif toolName == 'pfd': answer_train = [ pyeeg.pfd(i) for i in self.DataSet.trainSet_data[0] ] answer_test = [pyeeg.pfd(i) for i in self.DataSet.testSet_data[0]] print('pfd feature extraction succeed') elif toolName == 'bin_power': bandlist = [0.5, 4, 7, 12] #,30,100] answer_train = [ pyeeg.bin_power(i, bandlist, Fs) for i in self.DataSet.trainSet_data[0] ] answer_test = [ pyeeg.bin_power(i, bandlist, Fs) for i in self.DataSet.testSet_data[0] ] print('bin_power feature extraction succeed') else: print('does not have this kind of mode') answer_train = np.array(answer_train) answer_train = answer_train.reshape(len(answer_train), -1) answer_test = np.array(answer_test) answer_test = answer_test.reshape(len(answer_test), -1) if index == -1: #print(len(self.FeatureSet.feature.trainSet_feat[0]),len(answer_train)) self.FeatureSet.feature.trainSet_feat[0] = np.column_stack( (self.FeatureSet.feature.trainSet_feat[0], answer_train)) self.FeatureSet.feature.testSet_feat[0] = np.column_stack( (self.FeatureSet.feature.testSet_feat[0], answer_test)) self.FeatureSet.dict[0][toolName] = [ self.FeatureSet.size[0], self.FeatureSet.size[0] + len(answer_train[0]) ] self.FeatureSet.size[0] += len(answer_train[0]) else: self.FeatureSet.feature.trainSet_feat[0][:, index[0]:index[1]] = [ i for i in answer_train ] self.FeatureSet.feature.testSet_feat[0][:, index[0]:index[1]] = [ i for i in answer_test ]
"times": 10, "name": "fisher_info", "is_original": True, "fun": lambda x: pyeeg.fisher_info(x, 2, 3) }, { "times": 100, "name": "fisher_info", "is_original": False, "fun": lambda x: univ.fisher_info(x, 2, 3) }, { "times": 100, "name": "spectral_entropy", "is_original": True, "fun": lambda x: pyeeg.spectral_entropy(x, SPECT_ENT_BANDS, 256) }, { "times": 100, "name": "spectral_entropy", "is_original": False, "fun": lambda x: univ.spectral_entropy(x, 256, SPECT_ENT_BANDS) }, ] def make_one_rep(): ldfs = [] for n in range(MIN_EPOCH_N, MAX_EPOCH_N + 1, EPOCH_STEP): a = numpy.random.normal(size=n) for fun in fun_to_test:
def myFeaturesExtractor(X): # X has to be a matrix where each row is a channel N = len(X) # L = len(X[0]) # here we initialize the list of features // We will transform it to an array later featList = list() timeList =list () featName =list() for kChan in range(1): mySig = X[kChan , :] if kChan == 0: start=time.perf_counter_ns() #========== Stats ======================== myMean = np.mean(mySig) featList.append(myMean) if kChan == 0: end=time.perf_counter_ns() timeList.append(end -start) featName.append("mean") start=end featList.append(max(mySig)) if kChan == 0: end=time.perf_counter_ns() timeList.append(end -start) featName.append(" max") start=end featList.append(min(mySig)) if kChan == 0: end=time.perf_counter_ns() timeList.append(end -start) featName.append(" min") start=end peak =max(abs(mySig)) featList.append(peak) if kChan == 0: end=time.perf_counter_ns() timeList.append(end -start) featName.append(" peak") start=end myVar = np.var(mySig) featList.append(myVar) if kChan == 0: end=time.perf_counter_ns() timeList.append(end -start) featName.append(" var") start=end myVar = np.var(mySig) myStd = np.sqrt(myVar) featList.append(myStd) if kChan == 0: end=time.perf_counter_ns() timeList.append(end -start) featName.append(" std") start=end featList.append(sp.skew(mySig)) if kChan == 0: end=time.perf_counter_ns() timeList.append(end -start) featName.append(" skew") start=end featList.append(sp.kurtosis(mySig)) if kChan == 0: end=time.perf_counter_ns() timeList.append(end -start) featName.append(" kurt") start=end myRMS = rms(mySig) featList.append(myRMS) if kChan == 0: end=time.perf_counter_ns() timeList.append(end -start) featName.append(" rms") start=end myRMS = rms(mySig) featList.append(peak/myRMS) if kChan == 0: end=time.perf_counter_ns() timeList.append(end -start) featName.append(" fact") start=end myRMS = rms(mySig) featList.append(myRMS/myMean) if kChan == 0: end=time.perf_counter_ns() timeList.append(end -start) featName.append(" papr") start=end featList.append(totVar(mySig)) if kChan == 0: end=time.perf_counter_ns() timeList.append(end -start) featName.append(" totVar") start=end featList.append(pyeeg.dfa(mySig)) if kChan == 0: end=time.perf_counter_ns() timeList.append(end -start) featName.append(" dfa") start=end featList.append(pyeeg.hurst(mySig)) if kChan == 0: end=time.perf_counter_ns() timeList.append(end -start) featName.append(" hurst") start=end hMob , hComp = pyeeg.hjorth(mySig ) featList.append(hMob) if kChan == 0: end=time.perf_counter_ns() timeList.append(end -start) featName.append(" Hmob") timeList.append(end -start) featName.append(" Hcomp") start=end featList.append(hComp) # ## ======== fractal ======================== # # Now we need to get the embeding time lag Tau and embeding dmension # ac=delay.acorr(mySig, maxtau=maxTauLag, norm=True, detrend=True) # Tau = firstTrue(ac < corrThresh) # embeding delay # featList.append(Tau) # if kChan == 0: # end=time.perf_counter_ns() # # timeList.append(end -start) # featName.append(" dCorrTime") # start=end # f1 , f2 , f3 = dimension.fnn(mySig, dim=dim, tau=Tau, R=10.0, A=2.0, metric='chebyshev', window=10,maxnum=None, parallel=True) # myEmDim = firstTrue(f3 < fracThresh) ## if kChan == 0: ## end=time.perf_counter_ns() ## timeList.append(end -start) ## featName.append(" embDim") ## start=end # # Here we construct the Embeding Matrix Em # Em = pyeeg.embed_seq(mySig, Tau, myEmDim) # U, s, Vh = linalg.svd(Em) # W = s/np.sum(s) # list of singular values in decreasing order # # FInfo = pyeeg.fisher_info(X, Tau, myEmDim , W=W) # featList.append(FInfo) # if kChan == 0: # end=time.perf_counter_ns() # # timeList.append(end -start) # featName.append(" FInfo") # start=end # # featList.append(myEmDim) PFD = pyeeg.pfd(mySig, D=None) featList.append(PFD) if kChan == 0: end=time.perf_counter_ns() timeList.append(end -start) featName.append(" pfd") start=end hfd6 = pyeeg.hfd(mySig , 6) featList.append(hfd6) if kChan == 0: end=time.perf_counter_ns() timeList.append(end -start) featName.append(" hfd6") start=end hfd10 = pyeeg.hfd(mySig , 10) featList.append(hfd10) if kChan == 0: end=time.perf_counter_ns() timeList.append(end -start) featName.append(" hfd10") start=end # Now we fit aline and get its slope to have Lyapunov exponent # divAvg = lyapunov.mle(Em, maxt=maxtLyap, window= 3 * Tau, metric='euclidean', maxnum=None) # poly = np.polyfit(lyapLags, divAvg, 1, rcond=None, full=False, w=None, cov=False) # LyapExp = poly[0] # featList.append(np.mean(LyapExp)) # if kChan == 0: # end=time.perf_counter_ns() # # timeList.append(end -start) # featName.append("Lyapunov") # start=end ## ======== Entropy ======================== # here we compute bin power power, power_Ratio = pyeeg.bin_power(mySig , freqBins , Fs ) if kChan == 0: end=time.perf_counter_ns() timeList.append(end -start) featName.append("Spectral") start=end featList.append( pyeeg.spectral_entropy(mySig, freqBins, Fs, Power_Ratio=power_Ratio)) if kChan == 0: end=time.perf_counter_ns() timeList.append(end -start) featName.append(" specEn") start=end # tolerance = myStd / 4 # entropyDim = max([myEmDim , PFD]) # featList.append( pyeeg.samp_entropy(mySig , entropyDim , tolerance ) ) # if kChan == 0: # end=time.perf_counter_ns() # # timeList.append(end -start) # featName.append(" sampEn") # start=end # featList.append( pyeeg.svd_entropy(mySig, Tau, myEmDim , W=W) ) # if kChan == 0: # end=time.perf_counter_ns() # # timeList.append(end -start) # featName.append(" svdEn") # start=end ## ======== Spectral ======================== appendArray2List(featList , power ) appendArray2List(featList , power_Ratio ) start=time.perf_counter_ns() connectome(X , featList) end=time.perf_counter_ns() timeList.append((end -start)/N/(N-1)*2) featName.append("connectivity") ll=list() ll.append(featName) ll.append(timeList) return np.asarray(featList) , ll
def calculate_features(samples): data = samples if not samples: print("no samples") return [] band = [0.5, 4, 7, 12, 30] a = randn(4097) # approx = pyeeg.ap_entropy(data, 5, 1) approx = 0 DFA = pyeeg.dfa(data) first_order_diff = [data[i] - data[i - 1] for i in range(1, len(data))] fisher_info = pyeeg.fisher_info(data, 1, 1, W=None) embed_seq = pyeeg.embed_seq(data, 1, 1) hfd = pyeeg.hfd(data, 6) hjorth = pyeeg.hjorth(data, D=None) hurst = pyeeg.hurst(data) PFD = pyeeg.pfd(data) sam_ent = pyeeg.samp_entropy(data, 1, 2) spectral_entropy = pyeeg.spectral_entropy(data, band, 256, Power_Ratio=None) svd = pyeeg.svd_entropy(data, 6, 4, W=None) PSI = pyeeg.bin_power(data, band, 256) # # Power Spectral Intensity (PSI) and Relative Intensity Ratio (RIR) Two 1- D v ec t o rs # # print("bin_power = ", PSI) # # Petrosian Fractal Dimension (PFD) Ascalar # print("PFD = ", PFD) # # Higuchi Fractal Dimension (HFD) Ascalar # print("hfd = ", hfd) # # Hjorth mobility and complexity Two s c a la rs # print("hjorth = ", hjorth) # # Spectral Entropy (Shannon’s entropy of RIRs) Ascalar # print("spectral_entropy = ", spectral_entropy) # # SVD Entropy Ascalar # print("svd = ", svd) # # Fisher Information Ascalar # print("fisher_info = ", fisher_info) # # Approximate Entropy (ApEn) Ascalar # print("approx entrophy = ", approx) # # Detrended Fluctuation Analysis (DFA) Ascalar # print("DFA = ", DFA) # # HurstExponent(Hurst) Ascalar # print("Hurst_Exponent = ", hurst) # # Build a set of embedding sequences from given time series X with lag Tau and embedding dimension # print("embed_seq = ", embed_seq) # # Compute the first order difference of a time series. # print("first_order_diff = ", first_order_diff) return { 'approximate': approx, 'DFA': DFA, 'fisher_info': fisher_info, 'embed_seq': embed_seq, 'hfd': hfd, 'hjorth': hjorth, 'hurst': hurst, 'PFD': PFD, 'sam_ent': sam_ent, 'spectral_entropy': spectral_entropy, 'svd': svd, 'PSI': PSI, 'first_order_diff': first_order_diff }
##print i h = hjorth(X_train[i,]) hjorth_features_train.append(h) hjorth_features_test = [] for i in range(X_test.shape[0]): ##print i h = hjorth(X_test[i,]) hjorth_features_test.append(h) """Spectral Entropy """ ##Okay spectral_entropy_features_train = [] for i in range(X_train.shape[0]): ##print i h = spectral_entropy(X_train[i,], [0.54, 5, 7, 12, 50], 173, Power_Ratio=None) spectral_entropy_features_train.append(h) spectral_entropy_features_test = [] for i in range(X_test.shape[0]): ##print i h = spectral_entropy(X_test[i,], [0.54, 5, 7, 12, 50], 173, Power_Ratio=None) spectral_entropy_features_test.append(h) """SVD Entropy """ ## Okay svd_entropy_features_train = [] for i in range(X_train.shape[0]): ##print i h = svd_entropy(X_train[i,], 4, 10, W=None) svd_entropy_features_train.append(h)
def myFeaturesExtractor( X, myM, myV): # X has to be a matrix where each row is a channel N = len(X) # number of channels L = len(X[0]) maxtLyap = min(500, L // 2 + L // 4) lyapLags = np.arange(maxtLyap) / Fs # get number of features nFeatures = nMono * N + N * (N - 1) / 2 # here we initialize the list of features // We will transform it to an array later featList = np.zeros((int(nFeatures))) # deal with monovariate features first for kChan in range(N): kFeat = 0 mySig = X[kChan, :] #========== Stats ======================== myMean = myM[kChan] featList[nMono * kChan + kFeat] = myMean kFeat += 1 myMax = max(mySig) featList[nMono * kChan + kFeat] = myMax kFeat += 1 myMin = min(mySig) featList[nMono * kChan + kFeat] = myMin kFeat += 1 peak = max(abs(np.array([myMin, myMax]))) featList[nMono * kChan + kFeat] = peak kFeat += 1 myVar = myV[kChan] featList[nMono * kChan + kFeat] = myVar kFeat += 1 featList[nMono * kChan + kFeat] = sp.skew(mySig) kFeat += 1 featList[nMono * kChan + kFeat] = sp.kurtosis(mySig) kFeat += 1 myRMS = rms(mySig) featList[nMono * kChan + kFeat] = myRMS kFeat += 1 featList[nMono * kChan + kFeat] = peak / myRMS kFeat += 1 featList[nMono * kChan + kFeat] = totVar(mySig) kFeat += 1 featList[nMono * kChan + kFeat] = pyeeg.dfa(mySig) kFeat += 1 featList[nMono * kChan + kFeat] = pyeeg.hurst(mySig) kFeat += 1 hMob, hComp = pyeeg.hjorth(mySig) featList[nMono * kChan + kFeat] = hMob kFeat += 1 featList[nMono * kChan + kFeat] = hComp kFeat += 1 ## ======== fractal ======================== # Now we need to get the embeding time lag Tau and embeding dmension ac = delay.acorr(mySig, maxtau=maxTauLag, norm=True, detrend=True) Tau = firstTrue(ac < corrThresh) # embeding delay f1 , f2 , f3 = dimension.fnn(mySig, dim=dim, tau=Tau, R=10.0, A=2.0, metric='euclidean',\ window=10,maxnum=None, parallel=True) myEmDim = firstTrue(f3 < fracThresh) # Here we construct the Embeding Matrix Em Em = pyeeg.embed_seq(mySig, Tau, myEmDim) U, s, Vh = linalg.svd(Em) W = s / np.sum(s) # list of singular values in decreasing order FInfo = pyeeg.fisher_info(X, Tau, myEmDim, W=W) featList[nMono * kChan + kFeat] = FInfo kFeat += 1 featList[nMono * kChan + kFeat] = Tau kFeat += 1 featList[nMono * kChan + kFeat] = myEmDim kFeat += 1 #======================================== PFD = pyeeg.pfd(mySig, D=None) hfd6 = pyeeg.hfd(mySig, 6) hfd10 = pyeeg.hfd(mySig, 10) # Now we fit aline and get its slope to have Lyapunov exponent divAvg = lyapunov.mle(Em, maxt=maxtLyap, window=3 * Tau, metric='euclidean', maxnum=None) poly = np.polyfit(lyapLags, divAvg, 1, rcond=None, full=False, w=None, cov=False) LyapExp = poly[0] featList[nMono * kChan + kFeat] = PFD kFeat += 1 featList[nMono * kChan + kFeat] = hfd6 kFeat += 1 featList[nMono * kChan + kFeat] = hfd10 kFeat += 1 featList[nMono * kChan + kFeat] = LyapExp kFeat += 1 ## ======== Entropy ======================== tolerance = 1 / 4 entropyDim = max([myEmDim, PFD]) featList[nMono * kChan + kFeat] = pyeeg.samp_entropy( mySig, entropyDim, tolerance) kFeat += 1 featList[nMono * kChan + kFeat] = pyeeg.svd_entropy(mySig, Tau, myEmDim, W=W) kFeat += 1 # here we compute bin power power, power_Ratio = pyeeg.bin_power(mySig, freqBins, Fs) featList[nMono * kChan + kFeat] = pyeeg.spectral_entropy( mySig, freqBins, Fs, Power_Ratio=power_Ratio) kFeat += 1 ## ======== Spectral ======================== for kBin in range(len(freqBins) - 1): featList[nMono * kChan + kFeat] = power[kBin] kFeat += 1 featList[nMono * kChan + kFeat] = power_Ratio[kBin] kFeat += 1 # deal with multivariate features first #============ connectivity ================== corrList = connectome(X) nConnect = len(corrList) if N * (N - 1) / 2 != nConnect: raise ValueError('incorrect number of correlation coeffs') for kC in range(nConnect): featList[-nConnect + kC] = corrList[kC] return featList
#print vibration_list #vibration_array = np.zeros(fft_size) #for i in range(len(vibration_list)): # index = (vibration_list[i]-1) * sampling_rate # vibration_array[index:index+sampling_rate] = 1 (power_xf, power_xf_filtered, freqs, xfp) = return_filtered_epoch(time_series) dominant_f = return_dominant_freq(freqs, power_xf_filtered) (delta_ratio, theta_ratio, alpha_ratio, sigma_ratio, beta_ratio) = return_power_ratio(freqs, power_xf_filtered) (A5_mean, D5_mean, D4_mean, D3_mean, A5_std, D5_std, D4_std, D3_std, A5_pm, D5_pm, D4_pm, D3_pm, \ A5_ratio_mean, D5_ratio_mean, D4_ratio_mean, D3_ratio_mean) = return_DWT_feature(time_series) hurst_index = pyeeg.hurst(time_series) pfd_index = pyeeg.pfd(time_series) sp_entropy = pyeeg.spectral_entropy(time_series, [0.5, 3, 8, 12, 16, 30], sampling_rate, Power_Ratio = None) hj_activity, hj_mobility, hj_complexity = pyeeg.hjorth(time_series) fmax=getfmax(time_series) fmin=getfmin(time_series) fmean=getfmean(time_series) fstd=getfstd(time_series) fvar=getfvar(time_series) fskew=getfskew(time_series) fkur=getfkur(time_series) fmd=getfmd(time_series) zcnum=getzcnum(time_series) print [fmax, fmin, fmean, fstd, fvar, fskew, fkur, fmd, zcnum, dominant_f[0], delta_ratio, \ theta_ratio, alpha_ratio, sigma_ratio, beta_ratio, A5_mean, D5_mean, D4_mean, D3_mean, \ A5_std, D5_std, D4_std, D3_std, A5_pm, D5_pm, D4_pm, D3_pm, A5_ratio_mean, D5_ratio_mean, \
fun_to_test = [ {"times":100,"name":"hfd", "is_original":True,"fun": lambda x: pyeeg.hfd(x,2**3)}, {"times":100,"name":"hfd", "is_original":False,"fun": lambda x: univ.hfd(x,2**3)}, {"times":100,"name":"hjorth", "is_original":True,"fun": lambda x: pyeeg.hjorth(x)}, {"times":100,"name":"hjorth", "is_original":False,"fun": lambda x: univ.hjorth(x)}, {"times":100,"name":"pfd", "is_original":True, "fun":lambda x: pyeeg.pfd(x)}, {"times":100,"name":"pfd", "is_original":False, "fun":lambda x: pyeeg.pfd(x)}, {"times":2,"name":"samp_ent", "is_original":True, "fun":lambda x: pyeeg.samp_entropy(x,2,1.5)}, {"times":10,"name":"samp_ent", "is_original":False, "fun":lambda x: univ.samp_entropy(x,2,1.5,relative_r=False)}, {"times":2,"name":"ap_ent", "is_original":True, "fun":lambda x: pyeeg.ap_entropy(x,2,1.5)}, {"times":10,"name":"ap_ent", "is_original":False, "fun":lambda x: univ.ap_entropy(x,2,1.5)}, {"times":10,"name":"svd_ent", "is_original":True, "fun":lambda x: pyeeg.svd_entropy(x,2,3)}, {"times":100,"name":"svd_ent", "is_original":False, "fun":lambda x: univ.svd_entropy(x,2,3)}, {"times":10,"name":"fisher_info", "is_original":True, "fun":lambda x: pyeeg.fisher_info(x,2,3)}, {"times":100, "name":"fisher_info", "is_original":False, "fun":lambda x: univ.fisher_info(x,2,3)}, {"times":100,"name":"spectral_entropy", "is_original":True, "fun":lambda x: pyeeg.spectral_entropy(x,SPECT_ENT_BANDS,256)}, {"times":100, "name":"spectral_entropy", "is_original":False, "fun":lambda x: univ.spectral_entropy(x,256, SPECT_ENT_BANDS)}, ] def make_one_rep(): ldfs = [] for n in range(MIN_EPOCH_N, MAX_EPOCH_N + 1, EPOCH_STEP): a = numpy.random.normal(size=n) for fun in fun_to_test: f = lambda : fun["fun"](a) t=Timer(f) numb = fun["times"] dt = t.timeit(number=numb) fun["log10_dt"] = np.log10(dt/float(numb))
for i in range(X_train.shape[0]): ##print i h = hjorth(X_train[i, ]) hjorth_features_train.append(h) hjorth_features_test = [] for i in range(X_test.shape[0]): ##print i h = hjorth(X_test[i, ]) hjorth_features_test.append(h) '''Spectral Entropy ''' ##Okay spectral_entropy_features_train = [] for i in range(X_train.shape[0]): ##print i h = spectral_entropy(X_train[i, ], [0.54, 5, 7, 12, 50], 173, Power_Ratio=None) spectral_entropy_features_train.append(h) spectral_entropy_features_test = [] for i in range(X_test.shape[0]): ##print i h = spectral_entropy(X_test[i, ], [0.54, 5, 7, 12, 50], 173, Power_Ratio=None) spectral_entropy_features_test.append(h) '''SVD Entropy ''' ## Okay svd_entropy_features_train = [] for i in range(X_train.shape[0]): ##print i h = svd_entropy(X_train[i, ], 4, 10, W=None)
def myFeaturesExtractor1( X, myM, myV, myMin, myMax): # X has to be a matrix where each row is a channel N = len(X) # number of channels # L = len(X[0]) # get number of features nFeatures = nMono * N + N * (N - 1) / 2 # here we initialize the list of features // We will transform it to an array later featList = np.zeros((int(nFeatures))) # deal with monovariate features first for kChan in range(N): kFeat = 0 mySig = X[kChan, :] #========== Stats ======================== myMean = myM[kChan] featList[nMono * kChan + kFeat] = myMean kFeat += 1 featList[nMono * kChan + kFeat] = myMax[kChan] kFeat += 1 featList[nMono * kChan + kFeat] = myMin[kChan] kFeat += 1 myVar = myV[kChan] featList[nMono * kChan + kFeat] = myVar kFeat += 1 featList[nMono * kChan + kFeat] = sp.skew(mySig) kFeat += 1 featList[nMono * kChan + kFeat] = sp.kurtosis(mySig) kFeat += 1 featList[nMono * kChan + kFeat] = pyeeg.dfa(mySig) kFeat += 1 hMob, hComp = pyeeg.hjorth(mySig) featList[nMono * kChan + kFeat] = hMob kFeat += 1 featList[nMono * kChan + kFeat] = hComp kFeat += 1 ## ======== fractal ======================== # Now we need to get the embeding time lag Tau and embeding dmension ac = delay.acorr(mySig, maxtau=maxTauLag, norm=True, detrend=True) Tau = firstTrue(ac < corrThresh) # embeding delay featList[nMono * kChan + kFeat] = Tau kFeat += 1 PFD = pyeeg.pfd(mySig, D=None) hfd10 = pyeeg.hfd(mySig, 10) featList[nMono * kChan + kFeat] = PFD kFeat += 1 featList[nMono * kChan + kFeat] = hfd10 kFeat += 1 ## ======== Entropy ======================== # here we compute bin power power, power_Ratio = pyeeg.bin_power(mySig, freqBins, Fs) featList[nMono * kChan + kFeat] = pyeeg.spectral_entropy( mySig, freqBins, Fs, Power_Ratio=power_Ratio) kFeat += 1 ## ======== Spectral ======================== for kBin in range(len(freqBins) - 1): featList[nMono * kChan + kFeat] = power[kBin] kFeat += 1 featList[nMono * kChan + kFeat] = power_Ratio[kBin] kFeat += 1 # deal with multivariate features first #============ connectivity ================== corrList = connectome(X) nConnect = len(corrList) if N * (N - 1) / 2 != nConnect: raise ValueError('incorrect number of correlation coeffs') for kC in range(nConnect): featList[-nConnect + kC] = corrList[kC] return featList
def specEntropy4(X): frequencyBands = [0.1, 4, 8, 12, 30] power, powerRatio = pyeeg.bin_power(X[3], frequencyBands, glb.fs) return pyeeg.spectral_entropy(X[3], [0.1, 4, 7, 12, 30], 250, powerRatio)