def permu(d1, d2, d3, d4, d5):
pd1 = []
pd2 = []
pd3 = []
pd4 = []
pd5 = []
for i in range(0, 500):
X = d1[i]
print(i)
pd1.append(entropy.permutation_entropy(X, 3, 1))
for i in range(0, 500):
X = d2[i]
print(i)
pd2.append(entropy.permutation_entropy(X, 3, 1))
for i in range(0, 500):
X = d3[i]
print(i)
pd3.append(entropy.permutation_entropy(X, 3, 1))
for i in range(0, 500):
X = d4[i]
print(i)
pd4.append(entropy.permutation_entropy(X, 3, 1))
for i in range(0, 500):
X = d5[i]
print(i)
pd5.append(entropy.permutation_entropy(X, 3, 1))
return (pd1, pd2, pd3, pd4, pd5)
def MsPE_n(time_series, delay, m_start=3, m_end=7, plotting=False):
"""This function returns a suitable embedding dimension, given a time series and embedding delay, based on the
dimenion normalized MsPE at the optimum delay for a range of dimensions n.
Args:
ts (array): Time series (1d).
delay (int): Optimum delay from MsPE.
m_start (int): minimum dimension in dimension search. Default is 3.
m_end (int): maximum dimension in dimension search. Default is 8.
Kwargs:
plotting (bool): Plotting for user interpretation. defaut is False.
Returns:
(int): n, The embedding dimension for permutation formation.
"""
from pyentrp import entropy as ent
import numpy as np
MnPE = []
for m in range(m_start, m_end + 1):
PE = ent.permutation_entropy(time_series, m, delay) / (np.log(2))
NPE = PE / (m - 1)
MnPE = np.append(MnPE, NPE)
dim = np.argmax(MnPE)
if plotting == True:
D = delay
MSPE = []
MdoPE = []
for delay in range(1, int(1.5 * D)):
for m in range(m_start, m_end + 1):
PE = ent.permutation_entropy(time_series, m, delay)
NPE = PE / (m - 1)
MSPE = np.append(MSPE, NPE)
MdoPE = np.concatenate((MdoPE, MSPE), axis=0)
MSPE = []
MdoPE = MdoPE.reshape((int(1.5 * D) - 1, 1 + m_end - m_start)).T
import matplotlib.pyplot as plt
plt.figure(1)
TextSize = 17
plt.figure(figsize=(8, 3))
for m in range(0, m_end - m_start + 1):
plt.plot(np.linspace(1,
int(1.5 * D) - 1, len(MdoPE[m])),
MdoPE[m],
label='n = ' + str(m + m_start),
linewidth=2)
plt.plot([D, D], [0, 1.3], 'r--')
plt.xticks(size=TextSize)
plt.yticks(size=TextSize)
plt.ylabel(r'$H/(n-1)$', size=TextSize)
plt.xlabel(r'$\tau$', size=TextSize)
plt.legend(loc='lower right', borderaxespad=0.)
plt.show()
return dim + m_start
def n_op(time_series, delay):
"""This function returns a suitable embedding dimension, given a time series, based on the multi-scale permutation entropy algorithm.
Args:
delay (int): dimension n from the method of multi-scale permutation entropy.
ts (array): Time series array (1d).
Returns:
(int): n, The embedding dimension for permutation formation.
"""
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.gridspec as gridspec
import networkx as nx
from scipy import sparse
from ripser import ripser
from pyentrp import entropy as ent
import numpy as np
#returns an embedding dimenion suitable based on maximum permutation entropy per symbol
m_start, m_end = 3, 7
MnPE = []
for m in range(m_start, m_end + 1):
PE = ent.permutation_entropy(time_series, m, delay) / (np.log(2))
NPE = PE / (m - 1)
MnPE = np.append(MnPE, NPE)
dim = np.argmax(MnPE)
return dim + m_start
def PE(ts, n=5, tau=10, normalize=False):
"""This function takes a time series and calculates Permutation Entropy (PE).
Args:
ts (array): Time series (1d).
n (int): Permutation dimension. Default is 5.
tau (int): Permutation delay. Default is 10.
Kwargs:
normalize (bool): Normalizes the permutation entropy on scale from 0 to 1. defaut is False.
Returns:
(float): PE, the permutation entropy.
"""
from pyentrp import entropy as ent
import math
import numpy as np
PE = ent.permutation_entropy(ts, n, tau)
ME = 1
if normalize == True: ME = np.log2(math.factorial(n))
PE = PE / ME
return PE
def test_permutationEntropy(self):
self.assertEqual(
np.round(
ent.permutation_entropy(PERM_ENTROPY_BANDT, order=2, delay=1),
3), 0.918)
self.assertEqual(
np.round(
ent.permutation_entropy(PERM_ENTROPY_BANDT, order=3, delay=1),
3), 1.522)
# Assert that a fully random vector has an entropy of 0.99999...
self.assertEqual(
np.round(
ent.permutation_entropy(RANDOM_TIME_SERIES,
order=3,
delay=1,
normalize=True), 3), 0.999)
def permu(d1):
pd1 = []
print("Permutation started")
for i in range(d1.shape[0]):
X = d1[i]
pd1.append(entropy.permutation_entropy(X, 3, 1))
print("Permutation Finished")
return (pd1)
def perm_entrp(l):
"""
Permutation entropy
:param l:
:return:
"""
start = time.time()
se = e.permutation_entropy(l)
elapsed_time = time.time() - start
logger.debug("Elapsed time to calculate Permutation entropy value is %s",
elapsed_time)
return se
def extract_feature(X):
X = X.astype(float)
stft = np.abs(librosa.stft(X))
mfccs = np.mean(librosa.feature.mfcc(y=X, sr=SAMPLE_RATE, n_mfcc=40).T,
axis=0)
chroma = np.mean(librosa.feature.chroma_stft(S=stft, sr=SAMPLE_RATE).T,
axis=0)
mel = np.mean(librosa.feature.melspectrogram(X, sr=SAMPLE_RATE).T, axis=0)
shannon = [ent.shannon_entropy(X)]
sample = ent.sample_entropy(X, 1)
per = [ent.permutation_entropy(X)]
fft = np.fft.fft(X) / len(X)
fft = np.abs(fft[:len(X) // 7])
fft = [fft[0]]
return mfccs, chroma, mel, shannon, sample, per, fft
def permutation_entropy(signal_df, channels):
'''
Calculate permutation entropy of sensor signals.
:param signal_df: dataframe housing desired sensor signals
:param channels: channels of signal to measure permutation entropy
:return: dataframe of calculated permutation entropy for each signal channel
'''
from pyentrp import entropy as ent
permutation_entropy_df = pd.DataFrame()
for channel in channels:
current_perm_ent = ent.permutation_entropy(signal_df[channel], 4, 1)
permutation_entropy_df[channel +
'_permutation_entropy'] = [current_perm_ent]
return permutation_entropy_df
def MsPE(ts, n=5, delay_end=200, plotting=False, normalize=False):
"""This function takes a time series and calculates Multi-scale Permutation Entropy (MsPE)
over multiple time scales
Args:
ts (array): Time series (1d).
n (int): Permutation dimension. Default is 5.
delay_end (int): maximum delay in search. default is 200.
Kwargs:
plotting (bool): Plotting for user interpretation. defaut is False.
normalize (bool): Normalizes the permutation entropy on scale from 0 to 1. defaut is False.
Returns:
(array): MsPE, the permutation entropy over multiple time scales.
"""
from pyentrp import entropy as ent
import math
import numpy as np
MSPE = []
delays = []
m = n
for delay in np.arange(1, delay_end):
PE = ent.permutation_entropy(ts, m, delay)
ME = 1
if normalize == True: ME = np.log2(math.factorial(n))
PE = PE / ME
MSPE = np.append(MSPE, PE)
delays.append(delay)
if plotting == True:
import matplotlib.pyplot as plt
plt.figure(2)
TextSize = 17
plt.figure(figsize=(8, 3))
plt.plot(delays, MSPE, marker='.')
plt.xticks(size=TextSize)
plt.yticks(size=TextSize)
plt.ylabel(r'$h(3)$', size=TextSize)
plt.xlabel(r'$\tau$', size=TextSize)
plt.show()
return delays, MSPE
def extract_feature(X):
X = X.astype(float)
stft = np.abs(librosa.stft(X))
mfccs = np.mean(librosa.feature.mfcc(y=X, sr=SAMPLE_RATE, n_mfcc=40).T,
axis=0)
chroma = np.mean(librosa.feature.chroma_stft(S=stft, sr=SAMPLE_RATE).T,
axis=0)
mel = np.mean(librosa.feature.melspectrogram(X, sr=SAMPLE_RATE).T, axis=0)
shannon = [ent.shannon_entropy(X)]
sample = ent.sample_entropy(X, 1)
spectral = [np.round(spectral_entropy(X, SAMPLE_RATE), 2)]
per = [ent.permutation_entropy(X)]
energy_ent = [energy_entropy(X)]
energy_sig = [energy(X)]
zero_cross = [zero_crossing_rate(X)]
f, psd = welch(X, nfft=1024, fs=SAMPLE_RATE, noverlap=896, nperseg=1024)
fft = np.fft.fft(X) / len(X)
fft = np.abs(fft[:len(X) // 7])
fft = [fft[0]]
return np.concatenate(
(mfccs, chroma, mel, shannon, sample, spectral, per, energy_ent,
energy_sig, zero_cross, psd, chroma, fft))
hurst = m[0]*2.0 hurst #farctal dimension (correlation dimension)= slope of the line fitted to log(r) vs log(C(r)) # If the correlation dimension is constant for all ‘m’ the time series will be deterministic #if the correlation exponentincreases with increase in ‘m’ the time series will be stochastic. h01 = nolds.corr_dim(F,2,debug_plot=True) h01 #lyap_r = estimate largest lyapunov exponent h1=nolds.lyap_r(F,emb_dim=2,debug_plot=True) h1 #lyap_e = estimate whole spectrum of lyapunov exponents h2=nolds.lyap_e(F) h2 from pyentrp import entropy as ent T1=np.std(F) T1 k= 0.2*T1 k #sample entropy h = nolds.sampen(F,3,tolerance=k) h #permutation entropy h2=ent.permutation_entropy(F,order=3,normalize=True) h2
def basicalPE1D(self, normalize, order=3, delay=1):
PEnt = np.zeros(self.length)
for i in range(self.length):
tempStr = self.base[i]
PEnt[i] = ent.permutation_entropy(tempStr, order, delay, normalize)
return (PEnt)
def calculate_rri_nonlinear_statistics(self,
rri,
diff_rri,
diff2_rri,
suffix=''):
# Empty dictionary
rri_nonlinear_statistics = dict()
# Non-linear RR statistics
if len(rri) > 1:
rri_nonlinear_statistics['rri_approximate_entropy' + suffix] = \
self.safe_check(pyeeg.ap_entropy(rri, M=2, R=0.1*np.std(rri)))
rri_nonlinear_statistics['rri_sample_entropy' + suffix] = \
self.safe_check(ent.sample_entropy(rri, sample_length=2, tolerance=0.1*np.std(rri))[0])
rri_nonlinear_statistics['rri_multiscale_entropy' + suffix] = \
self.safe_check(ent.multiscale_entropy(rri, sample_length=2, tolerance=0.1*np.std(rri))[0])
rri_nonlinear_statistics['rri_permutation_entropy' + suffix] = \
self.safe_check(ent.permutation_entropy(rri, m=2, delay=1))
rri_nonlinear_statistics['rri_multiscale_permutation_entropy' + suffix] = \
self.safe_check(ent.multiscale_permutation_entropy(rri, m=2, delay=1, scale=1)[0])
rri_nonlinear_statistics['rri_fisher_info' + suffix] = fisher_info(
rri, tau=1, de=2)
hjorth_parameters = hjorth(rri)
rri_nonlinear_statistics['rri_activity' +
suffix] = hjorth_parameters[0]
rri_nonlinear_statistics['rri_complexity' +
suffix] = hjorth_parameters[1]
rri_nonlinear_statistics['rri_morbidity' +
suffix] = hjorth_parameters[2]
rri_nonlinear_statistics['rri_hurst_exponent' + suffix] = pfd(rri)
rri_nonlinear_statistics['rri_svd_entropy' + suffix] = svd_entropy(
rri, tau=2, de=2)
rri_nonlinear_statistics['rri_petrosian_fractal_dimension' +
suffix] = pyeeg.pfd(rri)
else:
rri_nonlinear_statistics['rri_approximate_entropy' +
suffix] = np.nan
rri_nonlinear_statistics['rri_sample_entropy' + suffix] = np.nan
rri_nonlinear_statistics['rri_multiscale_entropy' +
suffix] = np.nan
rri_nonlinear_statistics['rri_permutation_entropy' +
suffix] = np.nan
rri_nonlinear_statistics['rri_multiscale_permutation_entropy' +
suffix] = np.nan
rri_nonlinear_statistics['rri_fisher_info' + suffix] = np.nan
rri_nonlinear_statistics['rri_activity' + suffix] = np.nan
rri_nonlinear_statistics['rri_complexity' + suffix] = np.nan
rri_nonlinear_statistics['rri_morbidity' + suffix] = np.nan
rri_nonlinear_statistics['rri_hurst_exponent' + suffix] = np.nan
rri_nonlinear_statistics['rri_svd_entropy' + suffix] = np.nan
rri_nonlinear_statistics['rri_petrosian_fractal_dimension' +
suffix] = np.nan
# Non-linear RR difference statistics
if len(diff_rri) > 1:
rri_nonlinear_statistics['diff_rri_approximate_entropy' + suffix] = \
self.safe_check(pyeeg.ap_entropy(diff_rri, M=2, R=0.1*np.std(rri)))
rri_nonlinear_statistics['diff_rri_sample_entropy' + suffix] = \
self.safe_check(ent.sample_entropy(diff_rri, sample_length=2, tolerance=0.1*np.std(rri))[0])
rri_nonlinear_statistics['diff_rri_multiscale_entropy' + suffix] = \
self.safe_check(ent.multiscale_entropy(diff_rri, sample_length=2, tolerance=0.1*np.std(rri))[0])
rri_nonlinear_statistics['diff_rri_permutation_entropy' + suffix] = \
self.safe_check(ent.permutation_entropy(diff_rri, m=2, delay=1))
rri_nonlinear_statistics['diff_rri_multiscale_permutation_entropy' + suffix] = \
self.safe_check(ent.multiscale_permutation_entropy(diff_rri, m=2, delay=1, scale=1)[0])
rri_nonlinear_statistics['diff_rri_fisher_info' +
suffix] = fisher_info(diff_rri,
tau=1,
de=2)
hjorth_parameters = hjorth(diff_rri)
rri_nonlinear_statistics['diff_rri_activity' +
suffix] = hjorth_parameters[0]
rri_nonlinear_statistics['diff_rri_complexity' +
suffix] = hjorth_parameters[1]
rri_nonlinear_statistics['diff_rri_morbidity' +
suffix] = hjorth_parameters[2]
rri_nonlinear_statistics['diff_rri_hurst_exponent' +
suffix] = pfd(diff_rri)
rri_nonlinear_statistics['diff_rri_svd_entropy' +
suffix] = svd_entropy(diff_rri,
tau=2,
de=2)
rri_nonlinear_statistics['diff_rri_petrosian_fractal_dimension' +
suffix] = pyeeg.pfd(diff_rri)
else:
rri_nonlinear_statistics['diff_rri_approximate_entropy' +
suffix] = np.nan
rri_nonlinear_statistics['diff_rri_sample_entropy' +
suffix] = np.nan
rri_nonlinear_statistics['diff_rri_multiscale_entropy' +
suffix] = np.nan
rri_nonlinear_statistics['diff_rri_permutation_entropy' +
suffix] = np.nan
rri_nonlinear_statistics['diff_rri_multiscale_permutation_entropy'
+ suffix] = np.nan
rri_nonlinear_statistics['diff_rri_fisher_info' + suffix] = np.nan
rri_nonlinear_statistics['diff_rri_activity' + suffix] = np.nan
rri_nonlinear_statistics['diff_rri_complexity' + suffix] = np.nan
rri_nonlinear_statistics['diff_rri_morbidity' + suffix] = np.nan
rri_nonlinear_statistics['diff_rri_hurst_exponent' +
suffix] = np.nan
rri_nonlinear_statistics['diff_rri_svd_entropy' + suffix] = np.nan
rri_nonlinear_statistics['diff_rri_petrosian_fractal_dimension' +
suffix] = np.nan
# Non-linear RR difference difference statistics
if len(diff2_rri) > 1:
rri_nonlinear_statistics['diff2_rri_shannon_entropy' + suffix] = \
self.safe_check(ent.shannon_entropy(diff2_rri))
rri_nonlinear_statistics['diff2_rri_approximate_entropy' + suffix] = \
self.safe_check(pyeeg.ap_entropy(diff2_rri, M=2, R=0.1*np.std(rri)))
rri_nonlinear_statistics['diff2_rri_sample_entropy' + suffix] = \
self.safe_check(ent.sample_entropy(diff2_rri, sample_length=2, tolerance=0.1*np.std(rri))[0])
rri_nonlinear_statistics['diff2_rri_multiscale_entropy' + suffix] = \
self.safe_check(ent.multiscale_entropy(diff2_rri, sample_length=2, tolerance=0.1*np.std(rri))[0])
rri_nonlinear_statistics['diff2_rri_permutation_entropy' + suffix] = \
self.safe_check(ent.permutation_entropy(diff2_rri, m=2, delay=1))
rri_nonlinear_statistics['diff2_rri_multiscale_permutation_entropy' + suffix] = \
self.safe_check(ent.multiscale_permutation_entropy(diff2_rri, m=2, delay=1, scale=1)[0])
rri_nonlinear_statistics['diff2_rri_fisher_info' +
suffix] = fisher_info(diff2_rri,
tau=1,
de=2)
hjorth_parameters = hjorth(diff2_rri)
rri_nonlinear_statistics['diff2_rri_activity' +
suffix] = hjorth_parameters[0]
rri_nonlinear_statistics['diff2_rri_complexity' +
suffix] = hjorth_parameters[1]
rri_nonlinear_statistics['diff2_rri_morbidity' +
suffix] = hjorth_parameters[2]
rri_nonlinear_statistics['diff2_rri_hurst_exponent' +
suffix] = pfd(diff2_rri)
rri_nonlinear_statistics['diff2_rri_svd_entropy' +
suffix] = svd_entropy(diff2_rri,
tau=2,
de=2)
rri_nonlinear_statistics['diff2_rri_petrosian_fractal_dimension' +
suffix] = pyeeg.pfd(diff2_rri)
else:
rri_nonlinear_statistics['diff2_rri_shannon_entropy' +
suffix] = np.nan
rri_nonlinear_statistics['diff2_rri_approximate_entropy' +
suffix] = np.nan
rri_nonlinear_statistics['diff2_rri_sample_entropy' +
suffix] = np.nan
rri_nonlinear_statistics['diff2_rri_multiscale_entropy' +
suffix] = np.nan
rri_nonlinear_statistics['diff2_rri_permutation_entropy' +
suffix] = np.nan
rri_nonlinear_statistics['diff2_rri_multiscale_permutation_entropy'
+ suffix] = np.nan
rri_nonlinear_statistics['diff2_rri_fisher_info' + suffix] = np.nan
rri_nonlinear_statistics['diff2_rri_activity' + suffix] = np.nan
rri_nonlinear_statistics['diff2_rri_complexity' + suffix] = np.nan
rri_nonlinear_statistics['diff2_rri_morbidity' + suffix] = np.nan
rri_nonlinear_statistics['diff2_rri_hurst_exponent' +
suffix] = np.nan
rri_nonlinear_statistics['diff2_rri_svd_entropy' + suffix] = np.nan
rri_nonlinear_statistics['diff2_rri_petrosian_fractal_dimension' +
suffix] = np.nan
return rri_nonlinear_statistics
df_ = pd.DataFrame(rolling)
sw_1 = rolling[1]
sw_1_ns = rolling[1]
nolds.lyap_r(sw_1, emb_dim = emb_dim)
nolds.lyap_e(sw_1, emb_dim = emb_dim)
nolds.sampen(sw_1, emb_dim= emb_dim)
nolds.hurst_rs(sw_1)
nolds.corr_dim(sw_1, emb_dim=emb_dim)
nolds.dfa(sw_1)
ent.shannon_entropy(sw_1) # is this even valid? we do not have any p_i states i ALSO IGNORES TEMPORAL ORDER - Practical consideration of permutation entropy
ent.sample_entropy(sw_1, sample_length = 10) #what is sample length?
#ent.multiscale_entropy(sw_1, sample_length = 10, tolerance = 0.1*np.std(sw_1)) # what is tolerance?
"Practical considerations of permutation entropy: A Tutorial review - how to choose parameters in permutation entropy"
ent.permutation_entropy(sw_1, m=8, delay = emd_dim ) #Reference paper above
#ent.composite_multiscale_entropy()
lempel_ziv_complexity(sw_1)
gzip_compress_ratio(sw_1_ns, 9)
#https://www.researchgate.net/post/How_can_we_find_out_which_value_of_embedding_dimensions_is_more_accurate
#when choosing emb_dim for Takens, each dimension should have at least 10 dp ==> 10^1 == 1D, 10^2 == 2D, ..., 10^6 == 6D
#FALSE NEAREST NEIGHBOR FOR DETERMINING MINIMAL EMBEDDING DIMENSION
#MEASURES OF COMPLEXITY
# https://hackaday.io/project/707-complexity-of-a-time-series
# general entropy with discrete pdf - [H = sum_i - p_i * log( p_i)] , we cannot use because we have not well defined states
# Approximate entropy
def get_features(x_,fs_):
a_,psd_=get_psd_ama(x_,fs_)
psd_=psd_/np.sum(psd_)
b = np.where(a_<0.25)
feat_1 = psd_[b]
feat_1 = np.sum(feat_1)
c = np.where((a_ >0.25) & (a_<0.5))
feat_2 = psd_[c]
feat_2 = np.sum(feat_2)
d = np.where((a_ >0.5) & (a_<1.5))
feat_3 = psd_[d]
feat_3 = np.sum(feat_3)
feat_4 = -np.sum(psd_*np.log(psd_))
peaks, properties = find_peaks(psd_)
a1 = psd_[peaks]
a1=np.sort(a1)
if len(a1)>=3:
first, second, third=a1[-1], a1[-2], a1[-3]
elif len(a1)==2:
first,second,third=a1[-1], a1[-2], np.min(psd_)
elif len(a1)==1:
first,second,third=a1[-1], np.min(psd_), np.min(psd_)
elif len(a1)==0:
first,second,third=np.max(psd_), np.min(psd_), np.min(psd_)
#print(first, second, third)
feat_5=first/second
#print(feat_5)
feat_6=first/third
#print(feat_6)
feat_7 = kurtosis(psd_)
#print(feat_7)
feat_8 = skew(psd_)
feat_10 = FeatureSpectralFlatness(psd_, fs_)
#print(feat_10)
feat_11 = a_[np.argmax(psd_)]
#in band vs out of band ratio for feat 1
feat_12=feat_1/(feat_2+feat_3)
#in band vs out of band ratio for feat 1
feat_13=feat_2/(feat_1+feat_3)
#in band vs out of band ratio for feat 1
feat_14=feat_3/(feat_1+feat_2)
#get timeseries entropy (PE)
lag=1
feat_15=ent.permutation_entropy(x_,3,lag)
feat_c=np.hstack((feat_1, feat_2, feat_3, feat_4, feat_5, feat_6, feat_7, feat_8, feat_10, feat_11,feat_12,feat_13,feat_14,feat_15))
return feat_c
def delay_op(time_series, plotting=False):
"""This function returns a suitable embedding delay, given a time series, based on the multi-scale permutation entropy algorithm.
Args:
ts (array): Time series array (1d).
Kwargs:
plotting (bool): If True then the function will also plot the multi-scale permutation entropy plot for validation purposes.
Returns:
(int): tau, The embedding delay for permutation formation.
"""
#returns delay based on equioprobable permutations
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.gridspec as gridspec
import networkx as nx
from scipy import sparse
from ripser import ripser
from pyentrp import entropy as ent
import math
import numpy as np
flag = False
trip = 0.975 #sets trip value for knowing there is approximately a peak
MSPE = []
delays = []
ds = 1 #delay start
de = 200 #delay end
m = 3 #embedding dimension
start = False #hasn't started yet
end = False #hasn't found the first peak after noise yet
delay = ds
NPE_previous = 0 #initialize normalized permutation entropy (NPE)
while end == False: #While it hasn't found a peak
ME = np.log2(math.factorial(m))
PE = ent.permutation_entropy(time_series, m, delay)
NPE = PE / ME
delays.append(delay)
if NPE < trip:
start = True
if NPE > trip and start == True and end == False:
delay_peak = delay
end = True
NPE_previous = NPE
MSPE = np.append(MSPE, NPE)
if delay > de: #if it reaches the end
if flag == True: #if it didn't find an appropriate delay after the second pass
print('Warnings (1), (2), or (3):')
print(
'(1) Amplitude of noise is too large and exceeds signal.')
print(
'(2) If no noise or small amount, then time series is signficantly over sampled with'
)
print(
' Sampling Frequency greater than 100 times Nyquist rate.'
)
print('(3) The time series is from a discrete signal (Map).')
print('*** Delay = 1 is returned ***')
delay_peak = 1 #return delay of 1 (probably this is a map)
end = True
trip = trip + 0.025 #try again but higher trip value
flag = True #sets warning flag that this is the second pass
delay = 1 #restartes delay to 1
delay = delay + 1
L = len(time_series)
if L / delay_peak < 50:
print('Warning: delay may be inaccurate due to short time series')
if plotting == True:
plt.figure(figsize=(5, 3))
plt.plot(delays, MSPE, 'k.')
plt.xlabel(delay)
plt.ylabel('NPE')
plt.show()
return delay_peak
def permutation_entropy(X):
y = ent.permutation_entropy(X, 4, 1)
return y
def _permutation_entropy(self):
return permutation_entropy(self.MEAN_SPREAD, order=5, delay=1)
def entropy_acc(x, y, z, m):
x_feat = [ent.permutation_entropy(list(i)) for i in x]
y_feat = [ent.permutation_entropy(list(i)) for i in y]
z_feat = [ent.permutation_entropy(list(i)) for i in z]
m_feat = [ent.permutation_entropy(list(i)) for i in m]
return x_feat, y_feat, z_feat, m_feat
feat_11 = a[np.argmax(psd)]
#in band vs out of band ratio for feat 1
feat_12 = feat_1 / (feat_2 + feat_3)
#in band vs out of band ratio for feat 1
feat_13 = feat_2 / (feat_1 + feat_3)
#in band vs out of band ratio for feat 1
feat_14 = feat_3 / (feat_1 + feat_2)
#get timeseries entropy (PE)
lag = 1
x_ = br_epoch[:, ix]
print(x_.shape)
feat_15 = ent.permutation_entropy(x_, 3, lag)
feat_c = np.hstack(
(feat_1, feat_2, feat_3, feat_4, feat_5, feat_6, feat_7, feat_8,
feat_10, feat_11, feat_12, feat_13, feat_14, feat_15))
feat = np.vstack((feat, feat_c))
n = feat.shape[0]
print(n)
X0 = np.ones((n, 1))
print(X0.shape)
feat = np.hstack((feat, X0))
print(feat.shape)
df = pd.DataFrame(feat, columns=output_cols)
df.to_csv('/media/shruti/Data/Breathing_project/breathing_talk_devel_new.csv',
index=None)
def MsPE_tau(time_series, delay_end=200, plotting=False):
"""This function takes a time series and uses Multi-scale Permutation Entropy (MsPE) to find the optimum
delay based on the first maxima in the MsPE plot
Args:
ts (array): Time series (1d).
delay_end (int): maximum delay in search. default is 200.
Kwargs:
plotting (bool): Plotting for user interpretation. defaut is False.
Returns:
(int): tau, The embedding delay for permutation formation.
"""
trip = 0.9
from pyentrp import entropy as ent
import math
import numpy as np
MSPE = []
delays = []
ds, de = 0, delay_end
m = 3
start = False
end = False
delay = ds
NPE_previous = 0
while end == False:
delay = delay + 1
ME = np.log2(math.factorial(m))
PE = ent.permutation_entropy(time_series, m, delay)
NPE = PE / ME
if NPE < trip:
start = True
if NPE > trip and start == True and end == False:
if NPE < NPE_previous:
delay_peak = delay - 1
end = True
NPE_previous = NPE
MSPE = np.append(MSPE, NPE)
delays.append(delay)
if delay > de:
delay = 1
trip = trip - 0.05
if trip < 0.5:
delay = 1
end = True
if plotting == True:
import matplotlib.pyplot as plt
plt.figure(2)
TextSize = 17
plt.figure(figsize=(8, 3))
plt.plot(delays, MSPE, marker='.')
plt.xticks(size=TextSize)
plt.yticks(size=TextSize)
plt.ylabel(r'$h(3)$', size=TextSize)
plt.xlabel(r'$\tau$', size=TextSize)
plt.show()
return delay_peak
def test_permutationEntropy(self):
self.assertEqual(
np.round(ent.permutation_entropy(TS_SAMPLE_ENTROPY, 3, 5), 4),
1.7120)
