def test_spectral_entropy(self): spectral_entropy(RANDOM_TS, SF_TS, method='fft') spectral_entropy(RANDOM_TS, SF_TS, method='welch') spectral_entropy(RANDOM_TS, SF_TS, method='welch', nperseg=400) self.assertEqual(np.round(spectral_entropy(RANDOM_TS, SF_TS, normalize=True), 1), 0.9) self.assertEqual(np.round(spectral_entropy(PURE_SINE, 100), 2), 0.0)
def test_spectral_entropy(self): spectral_entropy(RANDOM_TS, SF_TS, method='fft') spectral_entropy(RANDOM_TS, SF_TS, method='welch') spectral_entropy(RANDOM_TS, SF_TS, method='welch', nperseg=400) self.assertEqual( np.round(spectral_entropy(RANDOM_TS, SF_TS, normalize=True), 1), 0.9) self.assertEqual(np.round(spectral_entropy(PURE_SINE, 100), 2), 0.0) # 2D data params = dict(sf=SF_TS, normalize=True, method='welch', nperseg=100) assert_equal(aal(spectral_entropy, axis=1, arr=data, **params), spectral_entropy(data, **params))
def entropy(x: np.array, freq: int = 1, base: float = e) -> Dict[str, float]: """Calculates sample entropy. Parameters ---------- x: numpy array The time series. freq: int Frequency of the time series Returns ------- dict 'entropy': Wrapper of the function spectral_entropy. References ---------- [1] https://raphaelvallat.com/entropy/build/html/index.html """ try: entropy = spectral_entropy(x, 1, normalize=True) except: entropy = np.nan return {'entropy': entropy}
def generate_csv(): cases_list = unpickle_data() csv_name = 'complete_data.csv' FULL_CSV = pd.DataFrame(columns=CSV_COLS) for c in cases_list: print(f" > Case {c._case_name}") for r in c: print(f"\t\t + RECORD {r.name}", end="") values = list() for k, v in r.N_LINEAR.items(): s = stats.describe(v) values.extend([ s[2], # Mean s[3], # Variance s[4], # Skewness spectral_entropy(v, sf=r.fs, method='fft') # Spectral Entropy ]) row_data = [ c._case_name, # Case r.name, # Record c.pathology, # Condition COND_ID[c.pathology], # Condition ID len(r.rr), # RR Length ] + values FULL_CSV = FULL_CSV.append(pd.Series(data=row_data, index=CSV_COLS), ignore_index=True) print("[v]") FULL_CSV.to_csv(csv_name, index=False)
def create_features(sound, sr): X = pd.DataFrame() segment_id = 0 FRAME_SIZE = 256 HOP_LENGTH = 128 tf = create_time_frequency(sound, frame_size=FRAME_SIZE, hop_length=HOP_LENGTH, rate=sr) centroid = librosa.feature.spectral_centroid( sound, sr=sr, n_fft=FRAME_SIZE, hop_length=HOP_LENGTH).transpose() X.loc[segment_id, 'centroid'] = np.min(centroid) / 1000 X.loc[segment_id, 'meanfreq'] = med_freq(sound, rate=sr) X.loc[segment_id, 'sd'] = np.std(tf) X.loc[segment_id, 'kurt'] = kurtosis(tf) X.loc[segment_id, 'skew'] = skew(tf) X.loc[segment_id, 'mode'] = mode(tf).mode[0] X.loc[segment_id, 'peakfreq'] = peak_freq(sound, sr) X.loc[segment_id, 'Q25'] = q25 = np.quantile(tf, 0.25) X.loc[segment_id, 'Q75'] = q75 = np.quantile(tf, 0.75) X.loc[segment_id, 'IQR'] = q75 - q25 X.loc[segment_id, 'sp.ent'] = ent.spectral_entropy(sound, sf=sr) X.loc[segment_id, 'sfm'] = np.std( librosa.feature.spectral_flatness(sound, n_fft=FRAME_SIZE, hop_length=128)) X.loc[segment_id, 'mindom'] = np.min(tf) return X
def entropy(x): ### Unpacking series (x, m) = x try: # Maybe 100 can change entropy = spectral_entropy(x, 1) except: entropy = np.nan return {'entropy': entropy}
def entropy4(x, normalize = False, base=None): value, counts = np.unique(x, return_counts=True) norm_counts = counts / counts.sum() base = e if base is None else base entr = -(norm_counts * np.log(norm_counts)/np.log(base)).sum() if normalize is True: entr /= np.log2(len(norm_counts)) print(entr) entr += spectral_entropy(x, sf=len(x), method='fft', normalize=normalize) return entr / 2
def process_row(row: pd.Series) -> pd.Series: data = dict(row[[m["tag"] for m in NL_METHODS]]) for tag, vec in data.items(): s = stats.describe(vec) values = [ s[2], s[3], s[4], spectral_entropy(vec, sf=row['fs'], method='fft') ] for n, v in zip(punctual_names, values): row[tag + n] = v return row
def main(args): if not os.path.exists(args.outdir): os.makedirs(args.outdir) df = pd.read_csv(args.result) states = [ col.split('true_')[1] for col in df.columns if col.startswith('true') ] true_cols = ['true_' + state for state in states] pred_cols = ['smooth_' + state for state in states] nclasses = len(true_cols) y_true = np.argmax(df[true_cols].values, axis=1) pred_prob = df[pred_cols].values y_pred = np.argmax(pred_prob, axis=1) indices = np.arange(y_true.shape[0]) feat_df = pd.read_csv(os.path.join(args.indir, 'features_30.0s.csv')) shape_df = pd.read_csv(os.path.join(args.indir, 'datashape_30.0s.csv')) num_samples = shape_df['num_samples'].values[0] num_timesteps = shape_df['num_timesteps'].values[0] num_channels = shape_df['num_channels'].values[0] rawdata = np.memmap(os.path.join(args.indir, 'rawdata_30.0s.npz'), mode='r', dtype='float32',\ shape=(num_samples, num_timesteps, num_channels)) # Get entropy of error scenarios spec_entropy = [] for idx in tqdm(indices): sidx = feat_df[(df.iloc[idx]['Filenames'] == feat_df['filename']) & ( df.iloc[idx]['Timestamp'] == feat_df['timestamp'])].index.values[0] enorm = np.sqrt(rawdata[sidx, :, 0]**2 + rawdata[sidx, :, 1]**2 + rawdata[sidx, :, 2]**2) spec_entropy.append(spectral_entropy(enorm, 50, normalize=True)) spec_entropy = np.array(spec_entropy) spec_entropy[np.isnan(spec_entropy)] = 0.0 # Plot probability distributions of true and pred states bins = 200 for i, true_state in enumerate(states): for j, pred_state in enumerate(states): chosen_indices = indices[(y_true == i) & (y_pred == j)] state_true_prob = pred_prob[chosen_indices, i] state_pred_prob = pred_prob[chosen_indices, j] true_prob_hist, true_prob_bins = get_hist(state_true_prob, bins) pred_prob_hist, pred_prob_bins = get_hist(state_pred_prob, bins) plot_hist(args.outdir, true_prob_bins, true_prob_hist, true_state,\ pred_prob_bins, pred_prob_hist, pred_state, metric='prob') state_true_ent = spec_entropy[(y_true == i) & (y_pred == i)] state_pred_ent = spec_entropy[(y_true == i) & (y_pred == j)] true_ent_hist, true_ent_bins = get_hist(state_true_ent, bins) pred_ent_hist, pred_ent_bins = get_hist(state_pred_ent, bins) plot_hist(args.outdir, true_ent_bins, true_ent_hist, true_state,\ pred_ent_bins, pred_ent_hist, pred_state, metric='ent')
def entropy(x, freq=1, normalize=False): """ Spectral Entropy """ try: start, stop = arg_longest_not_null(x) result = spectral_entropy(x[start:stop], sf=freq, method='welch', normalize=normalize) except Exception: result = np.nan finally: return result
def save_test(): TEST_DIRS = list(Path('.').glob('Test_*ws/')) for td in TEST_DIRS: t_cases = test_unpickle(td) pdir = "Test/" csv_name = pdir + td.stem + '.csv' pkl_name = pdir + td.stem + '.pkl' csv_data = pd.DataFrame(columns=CSV_COLS) pkl_data = pd.DataFrame(columns=CSV_COLS[:5]) for c in t_cases: for r in c: # Process for CSV values = list() row_data = [ c._case_name, r.name, c.pathology, COND_ID[c.pathology], len(r.rr_int), ] for k, v in r.N_LINEAR.items(): s = stats.describe(v) row_data.extend([ s[2], s[3], s[4], spectral_entropy(v, sf=r.fs, method='fft') ]) csv_data = csv_data.append(pd.Series( data=row_data, index=CSV_COLS, ), ignore_index=True) # Process for pickle pkl_row = { 'case': c._case_name, 'record': r.name, 'condition': c.pathology, 'cond_id': COND_ID[c.pathology], 'length': len(r.rr_int) } pkl_row.update(r.N_LINEAR) pkl_data = pkl_data.append(pd.DataFrame(pkl_row)) # DATA IS SAVED IN BOTH FORMATS csv_data.to_csv(csv_name, index=False) with open(pkl_name, 'wb') as pf: pickle.dump(pkl_data, pf)
def etrpy(sample, etype): if etype == "svd": et = entropy.svd_entropy(sample, order=3, delay=1) elif etype == "spectral": et = entropy.spectral_entropy(sample, 100, method='welch', normalize=True) elif etype == "sample": et = entropy.sample_entropy(sample, order=3) elif etype == "perm": et = entropy.perm_entropy(sample, order=3, normalize=True) else: print("Error: unrecognised entropy type {}".format(etype)) exit(-1) return et
def entropy(x, freq=1, normalize=False): """ Spectral Entropy """ if ENTROPY_PACKAGE_AVAILABLE: try: start, stop = arg_longest_not_null(x) result = spectral_entropy(x[start:stop], sf=freq, method='welch', normalize=normalize) except Exception: result = np.nan finally: return result else: raise ImportError('entropy package not found')
def compute_measures(self, window=[1000]): """ Computing some measures with the wind series :return: """ if self.raw_data is None: raise NameError("Raw data is not loaded") dvals = {} dvals['specent'] = spectral_entropy(self.raw_data[:, 0], sf=1) data = self.raw_data[:, 0] for w in window: length = int(data.shape[0] / w) size = w * length datac = data[:size] datac = datac.reshape(-1, w) means = np.mean(datac, axis=1) vars = np.std(datac, axis=1) dvals[f'Stab({w})'] = np.std(means) dvals[f'Lump({w})'] = np.std(vars) return dvals
def fun(a): # Returning the sum of elements at start index and at last index # inout array return spectral_entropy(a,100,normalize=True,method='welch')
def entropy(x): print(x) return spectral_entropy(x, sf=len(x), method='fft', normalize=True)
# ax1.set_ylabel('X', color=color) # ax1.plot(s[si], color=color) # ax1.tick_params(axis='y', labelcolor=color) # # ax2 = ax1.twinx() # color = 'tab:blue' # ax2.set_ylabel('S', color=color) # ax2.plot(S[si], color=color) # ax2.tick_params(axis='y', labelcolor=color) # # plt.show() # Entropy: print(entropy.perm_entropy(s[0], order=3, normalize=True)) # Permutation entropy print(entropy.spectral_entropy(s[0], 100, method='welch', normalize=True)) # Spectral entropy print(entropy.svd_entropy( s[0], order=3, delay=1, normalize=True)) # Singular value decomposition entropy print(entropy.app_entropy(s[0], order=2, metric='chebyshev')) # Approximate entropy print(entropy.sample_entropy(s[0], order=2, metric='chebyshev')) # Sample entropy fpath_db = os.path.join(os.path.dirname(__file__), 'data', '06-sir-gamma-beta.sqlite3') te = TrajectoryEnsemble(fpath_db).stats() s = te.traj[1].get_signal().series print(entropy.app_entropy(s[0], order=2, metric='chebyshev')) # Approximate entropy
def Figure_Diff_Features(): all_files_dataset1 = glob.glob(path + 'Segmentation/ID1/Figure_paper_B/' + 'T-*.csv') sigdata = [] features1_1 = np.array([]) features2_1 = np.array([]) features3_1 = np.array([]) features4_1 = np.array([]) features5_1 = np.array([]) timestamp = np.array([]) segment = np.array([]) for filename in all_files_dataset1: sigdata = pd.read_csv(filename, sep=',') head, tail = os.path.split(filename) ######Filtering########## signalfilt = np.array( BandpassFiilter(sigdata, Frequency_rate)['ppg_filt']) ########Peak Detection############# rpeaks = _Peak_detection(sigdata, signalfilt, Frequency_rate) #########Feature extraction############ df_features = pd.DataFrame( columns=['skewness', 'kurtosis', 'approxentro']) heartpeak = _segmentation_heartCycle(sigdata, signalfilt, rpeaks) for i in range(heartpeak.shape[0] - 1): heart_cycle = signalfilt[heartpeak[i]:heartpeak[i + 1]] f_skew = stats.skew(heart_cycle) f_kurt = stats.kurtosis(heart_cycle) f_appentropy = _aprox_Entropy(heart_cycle, 2, 7) df_features.loc[len(df_features)] = [f_skew, f_kurt, f_appentropy] timestamp = np.append(timestamp, tail) features1_1 = np.append(features1_1, _range(df_features['skewness'])) features2_1 = np.append(features2_1, _range(df_features['kurtosis'])) features3_1 = np.append(features3_1, _range(df_features['approxentro'])) features4_1 = np.append(features4_1, _Shannon_Entropy(signalfilt)) features5_1 = np.append( features5_1, spectral_entropy(signalfilt, Frequency_rate, method='welch')) all_files_dataset1 = glob.glob(path + 'Segmentation/ID1/Figure_paper_G/' + 'T-*.csv') sigdata = [] features1_2 = np.array([]) features2_2 = np.array([]) features3_2 = np.array([]) features4_2 = np.array([]) features5_2 = np.array([]) timestamp = np.array([]) segment = np.array([]) for filename in all_files_dataset1: sigdata = pd.read_csv(filename, sep=',') head, tail = os.path.split(filename) signalfilt = np.array( BandpassFiilter(sigdata, Frequency_rate)['ppg_filt']) rpeaks = _Peak_detection(sigdata, signalfilt, Frequency_rate) df_features = pd.DataFrame( columns=['skewness', 'kurtosis', 'approxentro']) heartpeak = _segmentation_heartCycle(sigdata, signalfilt, rpeaks) for i in range(heartpeak.shape[0] - 1): heart_cycle = signalfilt[heartpeak[i]:heartpeak[i + 1]] f_skew = stats.skew(heart_cycle) f_kurt = stats.kurtosis(heart_cycle) f_appentropy = _aprox_Entropy(heart_cycle, 2, 7) df_features.loc[len(df_features)] = [f_skew, f_kurt, f_appentropy] timestamp = np.append(timestamp, tail) features1_2 = np.append(features1_2, _range(df_features['skewness'])) features2_2 = np.append(features2_2, _range(df_features['kurtosis'])) features3_2 = np.append(features3_2, _range(df_features['approxentro'])) features4_2 = np.append(features4_2, _Shannon_Entropy(signalfilt)) features5_2 = np.append( features5_2, spectral_entropy(signalfilt, Frequency_rate, method='welch')) segment = [1, 2, 3, 4, 5] segment2 = [6, 7, 8, 9, 10] plt.figure(figsize=[6, 2.8]) plt.scatter(segment, features5_2, c='b', label='Reliable', s=100) plt.scatter(segment2, features5_1, c='r', label='Unreliable', s=100) plt.yticks(np.arange(0, 7, 1), fontsize=16) plt.xticks(np.arange(1, 11, 1), fontsize=16) #plt.tick_params(length=0.5, width=0.5) plt.xlabel('#Segment', fontsize=24) plt.ylabel('Amplitude', fontsize=24) plt.legend(fontsize=16) plt.grid(ls='-.') plt.show
def spec_entropy(x): return entropy.spectral_entropy(x, fs, method="welch", normalize=True)
def getdata(): ########################## Initial time to make my network settle down ###################### run(300 * ms) ############################################################################################## print(f"Freq input CTX = {rate_CTX} Hz\nFreq input STR = {rate_STR} Hz\n") """ Functions to monitor neurons' state """ spikemonitorSTN = SpikeMonitor(STNGroup, variables=['v']) statemonitorSTN = StateMonitor(STNGroup, ['v', 'I_lfp_stn', 'I_chem_GPe_STN'], record=True) statemonitorSTNRB = StateMonitor(STNRBGroup, ['v'], record=True) spikemonitorSTNRB = SpikeMonitor(STNRBGroup, variables=['v']) statemonitorSTNLLRS = StateMonitor(STNLLRSGroup, ['v'], record=True) spikemonitorSTNLLRS = SpikeMonitor(STNLLRSGroup, variables=['v']) statemonitorSTNNR = StateMonitor(STNNRGroup, ['v'], record=True) spikemonitorSTNNR = SpikeMonitor(STNNRGroup, variables=['v']) spikemonitorGPe = SpikeMonitor(GPeGroup, variables=['v']) statemonitorGPe = StateMonitor(GPeGroup, ['v', 'I_lfp_gpe', 'I_chem_STN_GPe'], record=True) statemonitorGPeA = StateMonitor(GPeAGroup, variables=['v'], record=True) spikemonitorGPeA = SpikeMonitor(GPeAGroup, variables=['v']) statemonitorGPeB = StateMonitor(GPeBGroup, variables=['v'], record=True) spikemonitorGPeB = SpikeMonitor(GPeBGroup, variables=['v']) statemonitorGPeC = StateMonitor(GPeCGroup, variables=['v'], record=True) spikemonitorGPeC = SpikeMonitor(GPeCGroup, variables=['v']) spikemonitorCTX = SpikeMonitor(CorticalGroup) ############################################################################################## run(duration) # Run boy, run! ############################################################################################## """ Calculating the Firing Rates for the entire simulation """ frGPe = firingrate(spikemonitorGPe, duration) frGPeA = firingrate(spikemonitorGPeA, duration) frGPeB = firingrate(spikemonitorGPeB, duration) frGPeC = firingrate(spikemonitorGPeC, duration) frSTN = firingrate(spikemonitorSTN, duration) frSTNRB = firingrate(spikemonitorSTNRB, duration) frSTNLLRS = firingrate(spikemonitorSTNLLRS, duration) frSTNNR = firingrate(spikemonitorSTNNR, duration) frCTX = firingrate(spikemonitorCTX, duration) frGPe = np.mean(frGPe) frGPeA = np.mean(frGPeA) frGPeB = np.mean(frGPeB) frGPeC = np.mean(frGPeC) frSTN = np.mean(frSTN) frSTNRB = np.mean(frSTNRB) frSTNLLRS = np.mean(frSTNLLRS) frSTNNR = np.mean(frSTNNR) """ Calculating ISI, mean ISI and standard deviation of ISI for each population. """ isiSTN, mean_isiSTN, std_isiSTN = isi_mean_std(spikemonitorSTN) isiSTNRB, mean_isiSTNRB, std_isiSTNRB = isi_mean_std(spikemonitorSTNRB) isiSTNLLRS, mean_isiSTNLLRS, std_isiSTNLLRS = isi_mean_std( spikemonitorSTNLLRS) isiSTNNR, mean_isiSTNNR, std_isiSTNNR = isi_mean_std(spikemonitorSTNNR) isiGPe, mean_isiGPe, std_isiGPe = isi_mean_std(spikemonitorGPe) isiGPeA, mean_isiGPeA, std_isiGPeA = isi_mean_std(spikemonitorGPeA) isiGPeB, mean_isiGPeB, std_isiGPeB = isi_mean_std(spikemonitorGPeB) isiGPeC, mean_isiGPeC, std_isiGPeC = isi_mean_std(spikemonitorGPeC) """ Calculating Coefficient of Variation: How irregular is the firing of my network? """ cv_gpe = coeffvar(std_isiGPe, mean_isiGPe) cv_gpea = coeffvar(std_isiGPeA, mean_isiGPeA) cv_gpeb = coeffvar(std_isiGPeB, mean_isiGPeB) cv_gpec = coeffvar(std_isiGPeC, mean_isiGPeC) cv_stn = coeffvar(std_isiSTN, mean_isiSTN) cv_stnrb = coeffvar(std_isiSTNRB, mean_isiSTNRB) cv_stnllrs = coeffvar(std_isiSTNLLRS, mean_isiSTNLLRS) cv_stnnr = coeffvar(std_isiSTNNR, mean_isiSTNNR) """ Calculating meaning currents: mean excitatory and inhibitory current and mean currents to STN and GPe """ mean_I_lfp_STN = np.mean(statemonitorSTN.I_lfp_stn, 0) mean_I_lfp_GPe = np.mean(statemonitorGPe.I_lfp_gpe, 0) """ Calculating spectra of LFP currents I obtained before This is done via scipy.signal.welch and scipy.integrate.simps """ filtered_lfp_STN = butter_bandpass_filter(mean_I_lfp_STN, 1, 100, 1 / deft, order=3) filtered_lfp_GPe = butter_bandpass_filter(mean_I_lfp_GPe, 1, 100, 1 / deft, order=3) fstn, specstn = welch(filtered_lfp_STN, fs=1 / deft, nperseg=2 / deft, nfft=2**18) fgpe, specgpe = welch(filtered_lfp_GPe, fs=1 / deft, nperseg=2 / deft, nfft=2**18) low = 12 * Hz high = 38 * Hz idx_beta_stn = np.logical_and(fstn >= low, fstn <= high) idx_beta_gpe = np.logical_and(fgpe >= low, fgpe <= high) freq_res_stn = fstn[1] - fstn[0] freq_res_gpe = fgpe[1] - fgpe[0] total_power_stn = simps(specstn, dx=freq_res_stn) total_power_gpe = simps(specgpe, dx=freq_res_gpe) beta_power_stn = simps(specstn[idx_beta_stn], dx=freq_res_stn) beta_power_gpe = simps(specgpe[idx_beta_gpe], dx=freq_res_gpe) """ Spectral Entropy of nuclei: How much peaked and concentrated is my beta band spectrum? """ specentropy_stn = spectral_entropy(filtered_lfp_STN, sf=1 / deft, method='welch', nperseg=2 / deft, normalize=True) specentropy_gpe = spectral_entropy(filtered_lfp_GPe, sf=1 / deft, method='welch', nperseg=2 / deft, normalize=True) """ Piece of code to calculate the synchronization between neuron in a single population and among the three populations of GPe and STN. """ var_time_v_GPe = variance_time_fluctuations_v(statemonitorGPe) norm_GPe = variance_time_flu_v_norm(N_GPe, statemonitorGPe) sync_par_GPe = sqrt(var_time_v_GPe / norm_GPe) var_time_v_STN = variance_time_fluctuations_v(statemonitorSTN) norm_STN = variance_time_flu_v_norm(N_STN, statemonitorSTN) sync_par_STN = sqrt(var_time_v_STN / norm_STN) var_time_v_GPeA = variance_time_fluctuations_v(statemonitorGPeA) norm_GPeA = variance_time_flu_v_norm(N_GPe_A, statemonitorGPeA) sync_par_GPeA = sqrt(var_time_v_GPeA / norm_GPeA) var_time_v_GPeB = variance_time_fluctuations_v(statemonitorGPeB) norm_GPeB = variance_time_flu_v_norm(N_GPe_B, statemonitorGPeB) sync_par_GPeB = sqrt(var_time_v_GPeB / norm_GPeB) var_time_v_GPeC = variance_time_fluctuations_v(statemonitorGPeC) norm_GPeC = variance_time_flu_v_norm(N_GPe_C, statemonitorGPeC) sync_par_GPeC = sqrt(var_time_v_GPeC / norm_GPeC) var_time_v_STNRB = variance_time_fluctuations_v(statemonitorSTNRB) norm_STNRB = variance_time_flu_v_norm(N_STN_RB, statemonitorSTNRB) sync_par_STNRB = sqrt(var_time_v_STNRB / norm_STNRB) var_time_v_STNLLRS = variance_time_fluctuations_v(statemonitorSTNLLRS) norm_STNLLRS = variance_time_flu_v_norm(N_STN_LLRS, statemonitorSTNLLRS) sync_par_STNLLRS = sqrt(var_time_v_STNLLRS / norm_STNLLRS) var_time_v_STNNR = variance_time_fluctuations_v(statemonitorSTNNR) norm_STNNR = variance_time_flu_v_norm(N_STN_NR, statemonitorSTNNR) sync_par_STNNR = sqrt(var_time_v_STNNR / norm_STNNR) """ Space reserved to plot useful stuff down here. """ """ Retrieving data I need for analysis """ data_provv = [ rate_CTX, rate_STR, frGPe, frGPeA, frGPeB, frGPeC, frSTN, frSTNRB, frSTNLLRS, frSTNNR, cv_gpe, cv_gpea, cv_gpeb, cv_gpec, cv_stn, cv_stnrb, cv_stnllrs, cv_stnnr, beta_power_stn / total_power_stn, beta_power_gpe / total_power_gpe, specentropy_stn, specentropy_gpe, sync_par_STNRB, sync_par_STNLLRS, sync_par_STNNR, sync_par_STN, sync_par_GPeA, sync_par_GPeB, sync_par_GPeC, sync_par_GPe ] data_provv = np.asarray(data_provv) return data_provv
def createEntropyFeatureArray(self, epochSeries : pd.Series, samplingFreq : int) -> (np.ndarray, List[str]): ''' Creates 3d Numpy with a entropy features - also returns the feature names Creates the following features: - Approximate Entropy (AE) - Sample Entropy (SamE) - Spectral Entropy (SpeE) - Permutation Entropy (PE) - Singular Value Decomposition Entropy (SvdE) For each channel there are 5 features then NaN Values will be set to Zero (not good but it works for now) ''' # Create np array, where the data will be stored d1 = len(epochSeries) # First Dimesion d2 = 1 # only one sample in that epoch channels = len(epochSeries[0].columns) d3 = channels * 5 # second dimension - 5 because we calculate five different entropies for each channel entropyFeatureArrayX = createEmptyNumpyArray(d1, d2, d3) # Create a list where all feature names are stored entropyFeatureList = [None] * d3 stepSize = 5 # step is 5 because we calculate 5 different entropies for i in range (0, len(epochSeries)): # loop through the epochs # We start the the stepz size and loop through the columns, but we have to multiply by the stepzsize and add once the step size (because we don't start at 0) for j in range(stepSize, (len(epochSeries[i].columns)*stepSize)+stepSize, stepSize): # loop through the columns # j_epoch is the normalized index for the epoch series (like the step size would be 1) j_epoch = j/stepSize - 1 # get the column name col = epochSeries[i].columns[j_epoch] # The values of the epoch of the current column colEpochList = epochSeries[i][col].tolist() ###################################### # calculate Approximate Entropy # ------------------------------------ val = entropy.app_entropy(colEpochList, order=2) # if the value is NaN, just set it to 0 if np.isnan(val): val = 0 entropyFeatureArrayX[i][0][j-1] = val # add approximate entropy feature to the list entropyFeatureList = addFeatureToList(featureList = entropyFeatureList, featureListIndex = j-1, newFeatureName = "{col}_approximate_entropy".format(col=col)) ###################################### # calculate Sample Entropy # ------------------------------------ val = entropy.sample_entropy(colEpochList, order=2) # if the value is NaN, just set it to 0 if np.isnan(val): val = 0 entropyFeatureArrayX[i][0][j-2] = val entropyFeatureList = addFeatureToList(featureList = entropyFeatureList, featureListIndex = j-2, newFeatureName = "{col}_sample_entropy".format(col=col)) ###################################### # calculate Spectral Entropy # ------------------------------------ val = entropy.spectral_entropy(colEpochList, sf=samplingFreq ,method='fft', normalize=True) # if the value is NaN, just set it to 0 if np.isnan(val): val = 0 entropyFeatureArrayX[i][0][j-3] = val entropyFeatureList = addFeatureToList(featureList = entropyFeatureList, featureListIndex = j-3, newFeatureName = "{col}_spectral_entropy".format(col=col)) ###################################### # calculate Permutation Entropy # ------------------------------------ val = entropy.perm_entropy(colEpochList, order=3, normalize=True, delay=1) # if the value is NaN, just set it to 0 if np.isnan(val): val = 0 entropyFeatureArrayX[i][0][j-4] = val entropyFeatureList = addFeatureToList(featureList = entropyFeatureList, featureListIndex = j-4, newFeatureName = "{col}_permutation_entropy".format(col=col)) ###################################### # calculate Singular Value Decomposition entropy. # ------------------------------------ val = entropy.svd_entropy(colEpochList, order=3, normalize=True, delay=1) # if the value is NaN, just set it to 0 if np.isnan(val): val = 0 entropyFeatureArrayX[i][0][j-5] = val entropyFeatureList = addFeatureToList(featureList = entropyFeatureList, featureListIndex = j-5, newFeatureName = "{col}_svd_entropy".format(col=col)) #break #break # Normalize everything to 0-1 print("Normalizing the entropy features...") # Norm=max -> then it will normalize between 0-1, axis=0 is important too! # We need to reshape it to a 2d Array X_entropy_norm = preprocessing.normalize(entropyFeatureArrayX.reshape(entropyFeatureArrayX.shape[0], entropyFeatureArrayX.shape[2]), norm='max', axis=0) # Now reshape it back to a simple 3D array X_entropy_norm = X_entropy_norm.reshape(X_entropy_norm.shape[0], 1, X_entropy_norm.shape[1]) return X_entropy_norm, entropyFeatureList
def main(): all_files_dataset1 = glob.glob(path + 'Segmentation/ID12/SixDay_30s/' + 'T-*.csv') sigdata = [] features1 = [] features2 = [] features3 = [] features4 = [] features5 = [] features6 = [] features7 = [] features8 = [] features9 = [] features10 = [] features11 = [] features12 = [] features13 = [] features14 = [] features15 = [] features16 = [] features17 = [] features18 = [] features19 = [] features20 = [] features21 = [] features22 = [] features23 = [] features24 = [] timestamp = [] for filename in all_files_dataset1: sigdata = pd.read_csv(filename, sep=',') head, tail = os.path.split(filename) timestamp.append(tail) signalfilt = np.array( BandpassFiilter(sigdata, Frequency_rate)['ppg_filt']) rpeaks = _Peak_detection(sigdata, signalfilt, Frequency_rate) df_features = pd.DataFrame( columns=['skewness', 'kurtosis', 'approxentro']) heartpeak = _segmentation_heartCycle(sigdata, signalfilt, rpeaks) for i in range(heartpeak.shape[0] - 1): heart_cycle = signalfilt[heartpeak[i]:heartpeak[i + 1]] f_skew = stats.skew(heart_cycle) f_kurt = stats.kurtosis(heart_cycle) f_appentropy = _aprox_Entropy(heart_cycle, 2, 7) df_features.loc[len(df_features)] = [f_skew, f_kurt, f_appentropy] features1.append(np.mean(signalfilt)) features2.append(np.std(signalfilt)) features3.append(np.median(signalfilt)) features4.append(_range(df_features['skewness'])) features5.append(_range(df_features['kurtosis'])) features6.append(_range(df_features['power'])) features7.append(_range(df_features['approxentro'])) features8.append(_Shannon_Entropy(signalfilt)) features9.append(_aprox_Entropy(signalfilt, 2, 7)) frequency_psd = signal.periodogram(signalfilt, fs=Frequency_rate)[0] amplitude_psd = signal.periodogram(signalfilt, fs=Frequency_rate)[1] features10.append( np.trapz( amplitude_psd[np.where( np.logical_and(frequency_psd >= 0.6, frequency_psd <= 0.8))], frequency_psd[np.where( np.logical_and( frequency_psd >= 0.6, frequency_psd <= 0.8))])) # between 0.6 to 0.8 features11.append( np.trapz( amplitude_psd[np.where( np.logical_and(frequency_psd >= 0.8, frequency_psd <= 1))], frequency_psd[np.where( np.logical_and(frequency_psd >= 0.8, frequency_psd <= 1))])) # between 0.8 to 1 features12.append( np.trapz( amplitude_psd[np.where( np.logical_and(frequency_psd >= 1, frequency_psd <= 1.2))], frequency_psd[np.where( np.logical_and( frequency_psd >= 1, frequency_psd <= 1.2))])) # between 1 to 1.2 features13.append( np.trapz( amplitude_psd[np.where( np.logical_and(frequency_psd >= 1.2, frequency_psd <= 1.4))], frequency_psd[np.where( np.logical_and( frequency_psd >= 1.2, frequency_psd <= 1.4))])) # between 1.2 to 1.4 features14.append( np.trapz( amplitude_psd[np.where( np.logical_and(frequency_psd >= 1.4, frequency_psd <= 1.6))], frequency_psd[np.where( np.logical_and( frequency_psd >= 1.4, frequency_psd <= 1.6))])) # between 1.4 to 1.6 features15.append( np.trapz( amplitude_psd[np.where( np.logical_and(frequency_psd >= 1.6, frequency_psd <= 1.8))], frequency_psd[np.where( np.logical_and( frequency_psd >= 1.6, frequency_psd <= 1.8))])) # between 1.6 to 1.8 features16.append( np.trapz( amplitude_psd[np.where( np.logical_and(frequency_psd >= 1.8, frequency_psd <= 2))], frequency_psd[np.where( np.logical_and(frequency_psd >= 1.8, frequency_psd <= 2))])) # between 1.8 to 2 features17.append( np.trapz( amplitude_psd[np.where( np.logical_and(frequency_psd >= 2, frequency_psd <= 2.2))], frequency_psd[np.where( np.logical_and( frequency_psd >= 2, frequency_psd <= 2.2))])) # between 2 to 2.2 features18.append( np.trapz( amplitude_psd[np.where( np.logical_and(frequency_psd >= 2.2, frequency_psd <= 2.4))], frequency_psd[np.where( np.logical_and( frequency_psd >= 2.2, frequency_psd <= 2.4))])) # between 2.2 to 2.4 features19.append( np.trapz( amplitude_psd[np.where( np.logical_and(frequency_psd >= 2.4, frequency_psd <= 2.6))], frequency_psd[np.where( np.logical_and( frequency_psd >= 2.4, frequency_psd <= 2.6))])) # between 2.4 to 2.6 features20.append( np.trapz( amplitude_psd[np.where( np.logical_and(frequency_psd >= 2.6, frequency_psd <= 2.8))], frequency_psd[np.where( np.logical_and( frequency_psd >= 2.6, frequency_psd <= 2.8))])) # between 2.6 to 2.8 features21.append( np.trapz( amplitude_psd[np.where( np.logical_and(frequency_psd >= 2.8, frequency_psd <= 3))], frequency_psd[np.where( np.logical_and(frequency_psd >= 2.8, frequency_psd <= 3))])) # between 2.8 to 3 features22.append(np.std(amplitude_psd)) features23.append(np.max(amplitude_psd)) features24.append( spectral_entropy(signalfilt, Frequency_rate, method='welch')) df_data = list( zip(*[ timestamp, features1, features2, features3, features4, features5, features6, features7, features8, features9, features10, features11, features12, features13, features14, features15, features16, features17, features18, features19, features20, features21, features22, features23, features24 ])) df = pd.DataFrame(df_data, columns=[ 'Timestamp', 'f1', 'f2', 'f3', 'f4', 'f5', 'f6', 'f7', 'f8', 'f9', 'f10', 'f11', 'f12', 'f13', 'f14', 'f15', 'f16', 'f17', 'f18', 'f19', 'f20', 'f21', 'f22', 'f23', 'f24' ]) df = df.dropna() #df.to_csv(path+'Features_ID1_30s_40.csv', mode='a', index=False) ######################Normalized######################### #print(df) df_z = pd.DataFrame(columns=['ave', 'std']) df_z['ave'] = ([ np.mean(df['f1']), np.mean(df['f2']), np.mean(df['f3']), np.mean(df['f4']), np.mean(df['f5']) ]) df_z['std'] = ([ np.std(df['f1']), np.std(df['f2']), np.std(df['f3']), np.std(df['f4']), np.std(df['f5']) ]) df['f1'] = (df['f1'] - df_z['ave'][0]) / df_z['std'][0] df['f2'] = (df['f2'] - df_z['ave'][1]) / df_z['std'][1] df['f3'] = (df['f3'] - df_z['ave'][2]) / df_z['std'][2] df['f4'] = (df['f4'] - df_z['ave'][3]) / df_z['std'][3] df['f5'] = (df['f5'] - df_z['ave'][4]) / df_z['std'][4] df['f6'] = (df['f6'] - df_z['ave'][5]) / df_z['std'][5] df['f7'] = (df['f7'] - df_z['ave'][6]) / df_z['std'][6] df['f8'] = (df['f8'] - df_z['ave'][7]) / df_z['std'][7] df['f9'] = (df['f9'] - df_z['ave'][8]) / df_z['std'][8] df['f10'] = (df['f10'] - df_z['ave'][9]) / df_z['std'][9] df['f11'] = (df['f11'] - df_z['ave'][10]) / df_z['std'][10] df['f12'] = (df['f12'] - df_z['ave'][11]) / df_z['std'][11] df['f13'] = (df['f13'] - df_z['ave'][12]) / df_z['std'][12] df['f14'] = (df['f14'] - df_z['ave'][13]) / df_z['std'][13] df['f15'] = (df['f15'] - df_z['ave'][14]) / df_z['std'][14] df['f16'] = (df['f16'] - df_z['ave'][15]) / df_z['std'][15] df['f17'] = (df['f17'] - df_z['ave'][16]) / df_z['std'][16] df['f18'] = (df['f18'] - df_z['ave'][17]) / df_z['std'][17] df['f19'] = (df['f19'] - df_z['ave'][18]) / df_z['std'][18] df['f20'] = (df['f20'] - df_z['ave'][19]) / df_z['std'][19] df['f21'] = (df['f21'] - df_z['ave'][20]) / df_z['std'][20] df['f22'] = (df['f22'] - df_z['ave'][21]) / df_z['std'][21] df['f23'] = (df['f23'] - df_z['ave'][22]) / df_z['std'][22] df['f24'] = (df['f24'] - df_z['ave'][23]) / df_z['std'][23] df_data = list( zip(*[ df['Timestamp'], df['f1'], df['f2'], df['f3'], df['f4'], df['f5'], df['f6'], df['f7'], df['f8'], df['f9'], df['f10'], df['f11'], df['f12'], df['f13'], df['f14'], df['f15'], df['f16'], df['f17'], df['f18'], df['f19'], df['f20'], df['f21'], df['f22'], df['f23'], df['f24'] ])) df_data = pd.DataFrame(df, columns=[ 'Timestamp', 'f1', 'f2', 'f3', 'f4', 'f5', 'f6', 'f7', 'f8', 'f9', 'f10', 'f11', 'f12', 'f13', 'f14', 'f15', 'f16', 'f17', 'f18', 'f19', 'f20', 'f21', 'f22', 'f23', 'f24' ]) df_data.to_csv(path + 'norm_features.csv', mode='a', index=False)