def get_sampen(arr, i): sampen = [] for data in arr: sampen.append(data[i]) return sampen2(normalize_data(sampen))
def initialize_parameters(self, vis=False): rate, sig = wav.read(filename=self.whole_name) self.total_length = sig.shape[0] / rate self.sampling_rate = rate t = np.arange(sig.shape[0]) / rate hilbert_envelope = hilbert(sig, N=int(sig.shape[-1] / 1)) analytic_signal = hilbert_envelope amplitude_envelope = np.abs(analytic_signal) #instantaneous_phase = np.unwrap(np.angle(analytic_signal)) #instantaneous_frequency = (np.diff(instantaneous_phase) /(2.0 * np.pi) * rate) normalized_amplitude_envelope = ( amplitude_envelope - np.mean(amplitude_envelope)) / np.std(amplitude_envelope) normalized_amplitude_envelope_variance = np.var( normalized_amplitude_envelope) self.normalized_amplitude_envelope_kurtosis = scipy.stats.kurtosis( normalized_amplitude_envelope) self.normalized_amplitude_envelope_variance = normalized_amplitude_envelope_variance self.signal_kurtosis = scipy.stats.kurtosis(sig) smen_duration = 3 #Sec self.sample_entropy = sampen2( normalized_amplitude_envelope[t < smen_duration], 2, 0.0008) max_time_to_show = 2 if vis: fig = plt.figure() ax0 = fig.add_subplot(111) max_time_to_show = 2 ax0.plot(t[t < max_time_to_show], sig[t < max_time_to_show], label='signal') ax0.plot(t[t < max_time_to_show], amplitude_envelope[t < max_time_to_show], label='envelope') ax0.set_xlabel("time in seconds") ax0.legend() #PHase #ax1 = fig.add_subplot(212) #ax1.plot(t[1:], instantaneous_frequency) #ax1.set_xlabel("time in seconds") #ax1.set_ylim(0.0, 120.0) max_time_to_show = 10 time_to_correlate = 1.5 corr_idx = int(time_to_correlate * rate) result = np.correlate(normalized_amplitude_envelope[0:corr_idx], normalized_amplitude_envelope, mode='full') result = result[corr_idx:]**2 normalized_result = (result - np.mean(result)) / np.std(result) self.max_correlation_peak = np.max(normalized_result[500:2330]) if vis == True: plt.figure() plt.plot(t[t < max_time_to_show], normalized_result[t < max_time_to_show]) plt.show()
def test_sampen2_with_defaults(self): data = [] with open(self.file_path, 'r') as file: for row in file: data.append(float(row.strip(' \t\n\r'))) self.assertEqual(sampen2(data, mm=2, r=0.2, normalize=False), [(0, 2.140629540027156, 0.0028357991885715863), (1, 2.162868347337613, 0.004903248034526253), (2, 2.123328492035711, 0.007596323621379352)])
def getSampEn(vector, m=2, r_multiply_by_sigma=.2): vector_np = np.asarray(vector) r = r_multiply_by_sigma * np.std(vector_np) results = sampen.sampen2(data=vector, mm=m, r=r) results_SampEN = [] for x in np.array(results)[:, 1]: if x is not None: results_SampEN.append(x) else: results_SampEN.append(-100.) return list(results_SampEN)
def toast(): # test get max arr = [[1, 2, 3], [1, 2, 3], [1, 5, 6]] assert get_max(arr, 1) == (5, 2) # test get min arr = [[1, 1, 3], [1, 2, 3], [1, 5, 6]] assert get_min(arr, 1) == (1, 0) argo = [1,3,5,7,53,4,586,54,5645,756,76,346,45758,56,42,223,6,3,6,3,6,3,0,-2,-68756,-6456,0,0,0,345,-12, -34,-34343,342,654,-34,0] print (sampen2(argo,2))
def mse_parc(imgfile, maskfile, atlasfile, outname, m, r, scales, verbose): """ Main function to run all steps for analysis on parcellated data """ # load data datadict = load_data(imgfile, maskfile, atlasfile, verbose) imgdata = datadict["imgdata"] mask = datadict["mask"] atlasdata = datadict["atlasdata"] regions = datadict["regions"] nregions = datadict["nregions"] numtps = datadict["numtps"] # parcellate data parc_data = parcellate_data(imgdata, atlasdata, numtps, regions, nregions, \ verbose) # standardize data parc_zdata = standardize_data(parc_data, nregions, verbose) # pre-allocate results array nscales = len(scales) result = np.zeros((nregions, nscales)) # loop over regions for region in range(0, nregions): if verbose: print("Working on region %d of %d" % (region + 1, nregions)) for scale_idx, scale in enumerate(scales): # do coarsegraining s = coarsegraining(parc_zdata[region, :], scale) # # compute sample entropy # [sampe, A, B] = sample_entropy(s,m+1,r) # # # grab sample entropy at specific scale # result[region, scale_idx] = sampe[m] # compute sample entropy sampe = se.sampen2(s, mm=m + 1, r=r, normalize=False) # grab sample entropy at specific scale result[region, scale_idx] = sampe[m][1] # save parcellated degree centrality image to disk if outname is not None: fname2save = "%s_mse_parc.nii.gz" % outname save_mse_parc_img(result, atlasfile, regions, fname2save, verbose) fname2save = "%s_mse_parc.csv" % outname save_mse_parc_csv(result, fname2save, regions) return (result)
def mean_sample_entropy_for_segment(self,segment): segments = self.get_segment(segment) segments = filter(lambda x: x.shape[0] != 0, segments) try: segments = np.concatenate(list(segments)) except ValueError: return np.nan ''' segments = map(lambda x: entr.sample_entropy(x.ravel(),1,.2*np.nanstd(x))[0],segments) segments = list(segments) ''' try: return smp.sampen2(list(segments.ravel())[:300],1,normalize=True)[1][1] except (ValueError, ZeroDivisionError): return np.nan
def test_sampen2_with_defaults(self): data = [] with open(self.file_path, 'r') as file: for row in file: data.append(float(row.strip(' \t\n\r'))) self.assertEqual( sampen2(data, mm=2, r=0.2, normalize=False), [ (0, 2.140629540027156, 0.0028357991885715863), (1, 2.162868347337613, 0.004903248034526253), (2, 2.123328492035711, 0.007596323621379352) ] )
def test_sampen2_matching_makefile(self): data = [] with open(self.file_path, 'r') as file: for row in file: data.append(float(row.strip(' \t\n\r'))) self.assertEqual(sampen2(data, mm=5, normalize=True), [ (0, 2.196817997610929, 0.002684778756853663), (1, 2.2248168592127824, 0.004639787747652105), (2, 2.1972245773362196, 0.007540128072706757), (3, 2.1552015875613715, 0.017693023262169073), (4, 2.315007612992603, 0.0331496460180921), (5, None, None), ])
def samp_ent(x, m=3, r=0.2): """ https://sampen.readthedocs.io/en/stable/#documentation :param r: :param m: :param x: time series data :return: sample entropy """ start_time = time.time() se = sampen2(x, mm=m, r=r) elapsed_time = time.time() - start_time rdo = se[len(se) - 1][1] logger.info("Sample Entropy %s", rdo) logger.debug("Elapsed time to calculate sample entropy is %s", elapsed_time) return rdo
def test_sampen2_matching_makefile(self): data = [] with open(self.file_path, 'r') as file: for row in file: data.append(float(row.strip(' \t\n\r'))) self.assertEqual( sampen2(data, mm=5, normalize=True), [ (0, 2.196817997610929, 0.002684778756853663), (1, 2.2248168592127824, 0.004639787747652105), (2, 2.1972245773362196, 0.007540128072706757), (3, 2.1552015875613715, 0.017693023262169073), (4, 2.315007612992603, 0.0331496460180921), (5, None, None), ] )
def seSQI (sig, rate, total_length): hilbert_envelope = hilbert(sig, N=int(sig.shape[-1] / 1)) amplitude_envelope = np.abs(hilbert_envelope) # instantaneous_phase = np.unwrap(np.angle(hilbert_envelope)) # instantaneous_frequency = (np.diff(instantaneous_phase) /(2.0 * np.pi) * rate) normalized_amplitude_envelope = (amplitude_envelope - np.mean(amplitude_envelope)) / np.std(amplitude_envelope) # Calculating the autocorrelation of the envelope, normalizing it, and removing the peak at Lag [0] - from David springer "Automated signal quality assessment..." auto_corr_sig = np.correlate(normalized_amplitude_envelope, normalized_amplitude_envelope, mode='full') trunc_sig = int(np.floor(auto_corr_sig.size / 2)) auto_corr_sig = auto_corr_sig[trunc_sig:] auto_corr_sig_norm = (auto_corr_sig - np.mean(auto_corr_sig)) / np.std(auto_corr_sig) first_zero_cross_idx = (np.where(np.diff(auto_corr_sig_norm) > 0))[0][0] + 1 auto_corr_sig_norm1 = auto_corr_sig_norm[first_zero_cross_idx:first_zero_cross_idx+5*rate if first_zero_cross_idx+5*rate<total_length*rate else np.size(auto_corr_sig_norm)] # Calculating the Sample Entropy return sampen2(auto_corr_sig_norm1, 2, 0.0008)[2][1], normalized_amplitude_envelope,auto_corr_sig_norm
def getSampEn(vector, m=2, r_multiply_by_sigma=.2): """ sample entropy NOTE: returns 3 values """ vector = np.asarray(vector) r = r_multiply_by_sigma * np.std(vector) try: results = sampen.sampen2(data=vector.tolist(), mm=m, r=r) except: return [0.0, 0.0, 0.0] results_SampEN = [] for x in np.array(results)[:, 1]: if x is not None: results_SampEN.append(x) else: results_SampEN.append(-100.) return list(results_SampEN)
def sampEntropy(rawEMGSignal): """ Parameters ---------- rawEMGSignal : ndarray an epoch of raw emg-signal Returns ------- feature_value : float sample entropy calculated from the rawEMGSignal for the parameters m = 2 and r = 0.2 * std """ copy_rawEMGSignal = copy.copy(rawEMGSignal) # shallow copy copy_feature = sampen2(normalize_data(list(copy_rawEMGSignal)))[2][1] if copy_feature is None: feature_value = 0 else: feature_value = copy_feature return feature_value
plt.subplot(121) plt.plot(rick_s[:sample]) plt.xlabel(f'time samples (first {sample})',fontsize=15) plt.ylabel('', fontsize=15) plt.subplot(122) plt.plot(rick_s) plt.xlabel('time samples',fontsize=15) plt.ylabel('', fontsize=15) plt.show() #%% m = [] se = [] print('RICK SERIE WAV') samp_ent = sampen.sampen2(rick_s.tolist(), mm=3, normalize=True) for i in range(3): print(f'\nm={i+1}') m.append(i+1) ent_mel, mel_A, mel_B, mel_i, mel_j, mel_match, mel_xm = sampen_own(rick_s, i+1, 0.2*np.std(rick_s),'max') se.append(ent_mel) print(f'Entropy: {ent_mel}') print(f'Entropy: {samp_ent[i+1][1]}') rick_entropy = pd.DataFrame({'m':m, 'entropy':se})
def emg_sampen(signal): sampen = sampen2(signal) sampen = [sampen[0][1], sampen[1][1], sampen[2][1]] return np.array(sampen)
plt.subplot(122) plt.plot(rick) plt.xlabel('time samples',fontsize=15) plt.ylabel('', fontsize=15) plt.show() #%% r_rick = 0.2*np.std(rick) print(r_rick) #%% RICK ENTROPY rick_ent,_,_,_,_,_,_ = sampen_own(rick[:5000], 2, r_rick,'max') print(rick_ent) rick_ent = sampen.sampen2(rick[:5000].tolist(), mm=2, normalize=True) print(rick_ent[2]) #%% print('RICK SERIE WAV') for i in range(3): ent_mel, mel_A, mel_B, mel_i, mel_j, mel_match, mel_xm = sampen_own(rick[:5000], i+1, 0.2*np.std(rick[:5000]),'max') samp_ent = sampen.sampen2(rick[:5000].tolist(), mm=3, normalize=True) print(f'\nEntropy: {ent_mel}') print(f'Entropy: {samp_ent[i+1][1]}')
def mse_img(imgfile, maskfile, outname, m, r, scales, verbose): """ Main function to run all steps for analysis on voxel-wise data """ if verbose: print("Computing voxel-wise mse map") # load data atlasfile = None datadict = load_data(imgfile, maskfile, atlasfile, verbose) imgdata = datadict["imgdata"] mask = datadict["mask"] numvoxels = datadict["nregions"] numtps = datadict["numtps"] voxsize = datadict["voxsize"] # grab indices of brain voxels within mask indices = np.transpose(np.nonzero(mask)) imgts = imgdata[indices[:, 0], indices[:, 1], indices[:, 2]] # standardize data imgts = standardize_data(imgts, numvoxels, verbose) # pre-allocate 4d result array nscales = len(scales) mse_dim = list(mask.shape) mse_dim.append(nscales) mse_dim = tuple(mse_dim) result = np.zeros(mse_dim) # loop over scales for scale_idx, scale in enumerate(scales): if verbose: print("Working on scale %d" % scale) tmp_img = np.zeros(mask.shape) # loop over voxels for basevoxel in range(0, numvoxels): if verbose: print("Working on %d voxel of %d voxels" % (basevoxel + 1, numvoxels)) #Get x,y,z coords for the voxel x, y, z = indices[basevoxel, :] # grab specific voxel's time-series ts = np.array(imgts[basevoxel, :]).reshape((numtps, 1)) # do coarsegraining s = coarsegraining(ts, scale) # # compute sample entropy # [sampe, A, B] = sample_entropy(s,m+1,r) # # # grab sample entropy at specific scale # tmp_img[x,y,z] = sampe[m] # compute sample entropy try: sampe = se.sampen2(s, mm=m + 1, r=r, normalize=False) # grab sample entropy at specific scale tmp_img[x, y, z] = sampe[m][1] except ZeroDivisionError: # grab sample entropy at specific scale tmp_img[x, y, z] = float("Inf") result[:, :, :, scale_idx] = tmp_img # save result to disk if outname is not None: fname2save = "%s_mse.nii.gz" % outname save_mse_vox_img(result, imgfile, fname2save, verbose) return (result)
def get_data(key): sig, fields = wfdb.srdsamp(recordname=key, channels=[1, 2, 5]) sig_processed = [preprocess(record * 2000) for record in sig.T] sig_processed = np.array(sig_processed) n = int(3.072 * fs_resampled) n_segment = sig_processed.shape[1] // n segments_ch2 = np.reshape(sig_processed[0, :n_segment * n], [n_segment, -1]) segments_ch3 = np.reshape(sig_processed[1, :n_segment * n], [n_segment, -1]) segments_ch_avf = np.reshape(sig_processed[2, :n_segment * n], [n_segment, -1]) features = [] for i in range(n_segment): coeff_ch2 = pywt.swt(data=segments_ch2[i], wavelet='db5', level=6) coeff_ch3 = pywt.swt(data=segments_ch3[i], wavelet='db5', level=6) coeff_ch_avf = pywt.swt(data=segments_ch_avf[i], wavelet='db5', level=6) coeff_2_ch2 = pywt.swt(data=segments_ch2[i]**2, wavelet='db5', level=6) coeff_2_ch3 = pywt.swt(data=segments_ch3[i]**2, wavelet='db5', level=6) coeff_2_ch_avf = pywt.swt(data=segments_ch_avf[i]**2, wavelet='db5', level=6) sen_d_1_3_3 = sampen.sampen2(data=list(coeff_ch3[-3][1]), mm=2, r=0.2, normalize=True)[2][1] nse_a_2_3_3 = compute_en(coeff_2_ch3[-3][0]) / sum( [compute_en(level[0]) for level in coeff_2_ch3]) #sen_d_1_avf_2=sampen.sampen2(data=list(coeff_ch_avf[-2][1]),mm=2,r=0.2,normalize=True)[2][1] lee_d_2_2_2 = sum( [np.log2((x)**2) if x != 0 else 0 for x in coeff_2_ch2[-2][1]]) nse_a_2_3_1 = compute_en(coeff_2_ch3[-1][0]) / sum( [compute_en(level[0]) for level in coeff_2_ch3]) sen_d_1_2_2 = sampen.sampen2(data=list(coeff_ch2[-2][1]), mm=2, r=0.2, normalize=True)[2][1] mds_d_1_2_2 = np.median( np.abs(coeff_ch2[-2][1][1:] - coeff_ch2[-2][1][:-1])) * fs_resampled sen_d_1_avf_2 = sampen.sampen2(data=list(coeff_ch_avf[-2][1]), mm=2, r=0.2, normalize=True)[2][1] lee_d_1_2_1 = sum( [np.log2((x)**2) if x != 0 else 0 for x in coeff_ch2[-1][1]]) mds_d_1_avf_1 = np.median( np.abs(coeff_ch_avf[-1][1][1:] - coeff_ch_avf[-1][1][:-1])) * fs_resampled feature = [ sen_d_1_3_3, nse_a_2_3_3, sen_d_1_avf_2, lee_d_2_2_2, nse_a_2_3_1, sen_d_1_2_2, mds_d_1_2_2, lee_d_1_2_1, mds_d_1_avf_1 ] features.append(np.array(feature)) if 'Myocardial infarction' in fields['comments'][4]: label = 1 if 'Healthy control' in fields['comments'][4]: label = 0 return (key, np.array(features), label)
for i in range(15): data_var[i] = np.var(data_sec[i]) #计算数据的方差 #离散小波变换 data_dwt_appro = np.zeros(15) #由离散小波变换得到的近似信号,也就是低频信息 data_dwt_detail = np.zeros(15) #由离散小波变换得到的细节信号,也就是高频信号 for i in range(15): Appro, Detail = pywt.dwt(data_sec[i],'db4') #根据阅读的文献,4阶Daubechies小波拥有最佳的对于EEG信号的处理效果,因此选择db4小波 data_dwt_appro[i] = np.mean(Appro) #对小波变换得到的数据计算均值 data_dwt_detail[i] = np.mean(Detail) data_dwt = [data_dwt_appro,data_dwt_detail] #样本熵 data_sampen = np.zeros(15) for i in range(15): data_temp = sampen2(data_sec[i]) #使用sampen模块中的sampen2函数进行样本熵的计算 data_temp2 = data_temp[2] #由于该函数会生成一个二维矩阵,而我们只需要第三个数组中的第二个数据 data_sampen[i] = data_temp2[1] #赫斯特指数 data_ApEn = np.zeros(15) for i in range(15): data_ApEn[i] = hurst(data_sec[i]) #使用pyeeg模块中的hurst函数计算赫斯特指数 #Petrosian分形维数 data_pfd = np.zeros(15) for i in range(15): data_pfd[i] = pfd(data_sec[i]) #使用pyeeg模块中的pfd计算Petrosian分形维数 ################################################################################################################### #将所有的属性值保存到xlsx文件中
def sampen_wavelet_coefs(y): try: return smp.sampen2(list(y)[:300],1, normalize=True)[1][1] except (ValueError, ZeroDivisionError): return np.nan
def get_features_from_window(window): features = [] cols = [ 'ax', 'ay', 'az', 'am', 'gx', 'gy', 'gz', 'gm', 'mx', 'my', 'mz', 'mm' ] for c in cols: col = window.loc[:, [c]] # 1 - Max mx = col.max() mxindex = col.idxmax() features.append(mx) # 2 - min of each n mn = col.min() mnindex = col.idxmin() features.append(mn) # 3 - mean of each n mean = col.mean() features.append(mean) # 4 - variance of each n variance = col.var() features.append(variance) # 5 - kurtosis of each n kurtosis = col.kurt() features.append(kurtosis) # 6 - skewness of each n skew = col.skew() features.append(skew) # 7 - peak to peak signal spp = mx - mn features.append(spp) # 8 - peak to peak time tpp = mxindex + mnindex features.append(tpp) # 9 - peak to peak slope if int(tpp) == 0: features.append(spp) else: spps = spp / tpp features.append(spps) # 10 - ALAR if int(mx) == 0: features.append(0) else: features.append(mxindex / mx) # 11 - Energy energy = np.einsum('ij,ij->j', col, col) features.append(energy[0]) # 12 - Entropy normalized = normalize(col) features.append(sampen2(normalized)[1][1]) return features