def test_eemd_simpleRun(self): T = np.linspace(0, 1, 100) S = np.sin(2*np.pi*T) eemd = EEMD(trials=10, max_imf=1) eemd.EMD.FIXE_H = 5 eemd.eemd(S)
def nonlinear_trend_test(trend): #Use surrogate method to test for EEMD trend significance t = len(trend) ts = trend.reshape(1, -1) #reshape into 2d array for surrogate methods ts_sur = timeseries.surrogates.Surrogates( ts) #generate an instance of surrogate class sur_list = [ ts ] #original time series is the first item in the surrogate list # Assign EEMD to `eemd` variable eemd = EEMD() eemd.noise_seed(12345) #detect extrema using parabolic method emd = eemd.EMD emd.extrema_detection = "parabol" for i in range(19): #0.05 significance level for one-sided test sur = ts_sur.refined_AAFT_surrogates( ts, 100 ) #Return surrogates using the iteratively refined amplitude adjusted Fourier transform method. #detrend surrogate eIMFs_n = eemd.eemd(sur.flatten(), np.arange(t)) sur_trend = eIMFs_n[-1] sur_list.append(sur_trend) ta_list = [timeAsymmetry(ts.flatten()) for ts in sur_list] #test statistic: time asymmetry return np.array(ta_list)
def read_data(): """ 读取data下面所有文件 :param time_steps: 采样率,输入数据的长度,步长 :return: """ eemd = EEMD() emd = eemd.EMD emd.extrema_detection = "parabol" for item in os.listdir('../data'): # 每读取一个文件,保存一个 print("start...{%s}" % item) # 获取文件名 short_name, _ = os.path.splitext(item) time_series = read_matdata('../data/' + item) # 将故障样本拆分为训练样本长度 input_length = time_series.shape[0] // TIME_PERIODS # 三维矩阵,记录每个输入样本长度,每个分量,信号信息 x = np.zeros((input_length, IMF_LENGTH, TIME_PERIODS)) # 获取序列最大长度,去掉信号后面的余数 idx_last = -(time_series.shape[0] % TIME_PERIODS) # 切片分割(input_length, time_steps) clips = time_series[:idx_last].reshape(-1, TIME_PERIODS) # 对每个样本做eemd处理 for i in range(clips.shape[0]): eimfs = eemd.eemd(clips[i]) print("start emf...%s-%d" % (item, i)) print(eimfs) x[i] = eimfs[0:IMF_LENGTH] # 将每个输入样本拉平,存储 b = x.reshape(input_length, -1) np.savetxt('../emd_data/' + short_name + '.txt', b) print(x)
def rolling_EEMD(sym, column, win, per, perend): datablock = get_data_for_EEMD(sym, column, per, perend) winlength = int(win * 24 * 12) t = np.linspace(0, winlength - 1, winlength) eemd = EEMD() emd = eemd.EMD emd.extrema_detection = "parabol" nIMF = [] last = [] dlast = [] timelist = [] timearray = datablock.index[(winlength):] for i in tqdm(range(winlength, datablock.__len__(), 1)): datawindow = datablock.iloc[i - winlength:i] # Execute EEMD on window maximf = 6 eIMFs = eemd.eemd(datawindow.tolist(), t, max_imf=maximf) nIMFs = eIMFs.shape[0] nIMF.append(nIMFs) last.append(eIMFs[0:nIMFs, -1]) d = eIMFs[0:nIMFs, -1] - eIMFs[0:nIMFs, -2] dlast.append(d) timelist.append(datawindow.index[-1]) lastdf = pd.DataFrame(last, index=timearray) dlastdf = pd.DataFrame(dlast, index=timearray) return [lastdf, dlastdf]
def main(): e = exchange.Exchange('../lib/binance.db') start = datetime.datetime(2018, 8, 1) end = datetime.datetime(2019, 8, 1) params = parameter_estimation.calculate_parameters(start, end, 6, e) eemd = EEMD() emd = eemd.EMD eIMFs_rate = eemd.eemd(np.array([p[1] for p in params])) fig, axs = plt.subplots(eIMFs_rate.shape[0], figsize=(12, eIMFs_rate.shape[0] * 3)) rate = np.zeros(eIMFs_rate.shape[1]) for ax, IMF in zip(axs, eIMFs_rate): #ax.plot(IMF) ax.plot(IMF) analytic_signal = hilbert(IMF) phase = np.unwrap(np.angle(analytic_signal)) freq = np.diff(phase) / (2 * np.pi * 0.25) print(np.mean(1 / freq)) plt.tight_layout() plt.show()
def test_eemd_passingArgumentsViaDict(self): trials = 10 noise_kind = 'uniform' spline_kind = 'linear' # Making sure that we are not testing default options eemd = EEMD() self.assertFalse(eemd.trials == trials, self.cmp_msg(eemd.trials, trials)) self.assertFalse(eemd.noise_kind == noise_kind, self.cmp_msg(eemd.noise_kind, noise_kind)) self.assertFalse(eemd.EMD.spline_kind == spline_kind, self.cmp_msg(eemd.EMD.spline_kind, spline_kind)) # Testing for passing attributes via params eemd = EEMD(trials=trials, noise_kind=noise_kind, spline_kind=spline_kind) self.assertTrue(eemd.trials == trials, self.cmp_msg(eemd.trials, trials)) self.assertTrue(eemd.noise_kind == noise_kind, self.cmp_msg(eemd.noise_kind, noise_kind)) self.assertTrue(eemd.EMD.spline_kind == spline_kind, self.cmp_msg(eemd.EMD.spline_kind, spline_kind))
def test_eemd_noiseSeed(self): T = np.linspace(0, 1, 100) S = np.sin(2*np.pi*T+ 4**T) + np.cos( (T-0.4)**2) # Compare up to machine epsilon cmpMachEps = lambda x, y: np.abs(x-y)<=2*np.finfo(x.dtype).eps config = {"processes": 1} eemd = EEMD(trials=10, **config) # First run random seed eIMF1 = eemd(S) # Second run with defined seed, diff than first eemd.noise_seed(12345) eIMF2 = eemd(S) # Extremly unlikely to have same seed, thus different results msg_false = "Different seeds, expected different outcomes" if eIMF1.shape == eIMF2.shape: self.assertFalse(np.all(cmpMachEps(eIMF1,eIMF2)), msg_false) # Third run with same seed as with 2nd eemd.noise_seed(12345) eIMF3 = eemd(S) # Using same seeds, thus expecting same results msg_true = "Used same seed, expected same results" self.assertTrue(np.all(cmpMachEps(eIMF2,eIMF3)), msg_true)
def FEI(_data, NFFT = 1024): N = len(_data) width = _data.shape[1] n = NFFT _data = (np.vstack((np.zeros((n,width)), zmean(_data),np.zeros((n-N%n,width))))) # w = signal.windows.chebwin(n, 100).reshape((n,1)) # y = np.zeros_like(_data, dtype=complex) # for ii in range(0, len(_data)-n, n//2): # Y = _data[ii:ii+n,:]*w # k = (1j*2*pi*fftfreq(len(Y), dt).reshape((n,1))) # y[ii:ii+n,:] = (ifft(np.vstack((np.zeros((1,width)),fft(Y, axis=0)[1:]/(k[1:]))), axis=0)) # _datai = zmean(np.real(y)) _datai = zmean(integ(_data)) # return _datai[n:N+n] _dataI = np.zeros_like(_datai) for ii in range(0, len(_data)-n, n): for jj in range(width): F0 = featExt(_datai[ii:ii+n,jj]) eemd = EEMD(noise_width=0.15) eIMFs = eemd.eemd(_datai[ii:ii+n,jj]).T F = [] for kk in range(eIMFs.shape[1]): F.append(featExt(eIMFs[:,kk])) nn = norm(np.array(F)**2-F0, axis=1).argmin() _dataI[ii:ii+n,jj] = eIMFs[:,nn] return _dataI[n:N+n]
def test_eemd_simpleRun(): T = np.linspace(0, 1, 100) S = np.sin(2*np.pi*T) config = {"processes": 1} eemd = EEMD(trials=10, max_imf=1, **config) eemd.EMD.FIXE_H = 5 eemd.eemd(S)
def __init__(self, trails, n_component, whiten=True, max_iter=200): self.ceemdan = CEEMDAN(trials=trails) self.eemd = EEMD(trails=trails) self.emd = EMD() self.n_component = n_component self.ICA_transfomer = FastICA(n_components=n_component, whiten=whiten, max_iter=max_iter)
def test_imfs_and_residue_accessor(self): S = np.random.random(100) eemd = EEMD(trials=5, max_imf=2, parallel=False) eIMFs = eemd(S) imfs, residue = eemd.get_imfs_and_residue() self.assertEqual(eIMFs.shape[0], imfs.shape[0], "Compare number of components") self.assertEqual(len(residue), 100, "Check if residue exists")
def extract_imfs(self, signal): eemd = EEMD() eemd.eemd(signal) res = eemd.get_imfs_and_residue() imfs = list(res)[0] # drop the noise/ high frequency imfs, may incur index error due to the signal is too simple imfs_left = imfs[-1:] return imfs_left # np.array type
def main(): #load data e = exchange.Exchange('../lib/binance.db') start = int(datetime.datetime(2018, 7, 1).timestamp() * 1000) #end = int(datetime.datetime(2018, 8, 1).timestamp() * 1000) end = int(datetime.datetime(2019, 7, 1).timestamp() * 1000) print('Loading order data...') number_of_orders, prices = e.get_total_orders_ts('BTCUSDT', 24 * 60 * 60 * 1000, start, end) #hourly data print('done') buy_orders = np.array([b for s, b in number_of_orders]) sell_orders = np.array([s for s, b in number_of_orders]) t = [i for i, o in enumerate(buy_orders)] eemd = EEMD() emd = eemd.EMD eIMFs_buys = eemd.eemd(buy_orders) eIMFs_sells = eemd.eemd(sell_orders) if eIMFs_buys.shape[0] != eIMFs_sells.shape[0]: print('size mismatch') n = min(eIMFs_buys.shape[0], eIMFs_sells.shape[0]) fig, axs = plt.subplots(3, figsize=(12, 9), sharex=True) axs[0].plot(prices) axs[0].set_ylabel('Price') buys = np.sum(eIMFs_buys[1:-2], axis=0) sells = np.sum(eIMFs_sells[1:-2], axis=0) axs[1].plot(buys, color='g') axs[1].plot(sells, color='r') axs[2].plot(calculate_returns(prices), color='b') ax3 = axs[2].twinx() ax3.plot((0, len(prices)), (0.5, 0.5)) ax3.plot(buys - sells) plt.xlabel("Time /days") #plt.tight_layout() plt.show()
def test_eemd_simpleRun(self): T = np.linspace(0, 1, 100) S = np.sin(2 * np.pi * T) config = {"processes": 1} eemd = EEMD(trials=10, max_imf=1, **config) eemd.EMD.FIXE_H = 5 eemd.eemd(S) self.assertTrue('pool' in eemd.__dict__)
def test_eemd_notParallel(self): S = np.random.random(100) eemd = EEMD(trials=5, max_imf=2, parallel=False) eemd.EMD.FIXE_H = 2 eIMFs = eemd.eemd(S) self.assertTrue(eIMFs.shape[0] > 0) self.assertTrue(eIMFs.shape[1], len(S)) self.assertFalse('pool' in eemd.__dict__)
def hht(data, time, freqsol=33, timesol=50): # freqsol give frequency - axis resolution for hilbert - spectrum # timesol give time - axis resolution for hilbert - spectrum t0 = time[0] t1 = time[-1] dt = (t1 - t0) / (len(time) - 1) eemd = EEMD() imfs = eemd.eemd(data) freq, amp = FAhilbert(imfs, dt) # fw0 = np.min(np.min(freq)) # maximum frequency # fw1 = np.max(np.max(freq)) # maximum frequency # if fw0 <= 0: # fw0 = np.min(np.min(freq[freq > 0])) # only consider positive frequency # fw = fw1-fw0 tw = t1 - t0 bins = np.linspace(0, 12, freqsol) #np.logspace(0, 10, freqsol, base=2.0) p = np.digitize(freq, 2**bins) t = np.ceil((timesol - 1) * (time - t0) / tw) t = t.astype(int) hilbert_spectrum = np.zeros([timesol, freqsol]) for i in range(len(time)): for j in range(imfs.shape[0] - 1): if p[i, j] >= 0 and p[i, j] < freqsol: hilbert_spectrum[t[i], p[i, j]] += amp[i, j] hilbert_spectrum = abs(hilbert_spectrum) fig1 = plt.figure(figsize=(5, 5)) plot_imfs(data, imfs, time_samples=time, fig=fig1) fig2 = plt.figure(figsize=(5, 5)) plot_frequency(data, freq.T, time_samples=time, fig=fig2) fig0 = plt.figure(figsize=(5, 5)) ax = plt.gca() c = ax.contourf( np.linspace(t0, t1, timesol), bins, hilbert_spectrum.T ) #, colors=('whites','lategray','navy','darkgreen','gold','red') ax.invert_yaxis() ax.set_yticks(np.linspace(1, 11, 11)) Yticks = [float(math.pow(2, p)) for p in np.linspace(1, 11, 11)] # make 2^periods ax.set_yticklabels(Yticks) ax.set_xlabel('Time', fontsize=8) ax.set_ylabel('Period', fontsize=8) position = fig0.add_axes([0.2, 0.05, 0.6, 0.01]) cbar = plt.colorbar(c, cax=position, orientation='horizontal') cbar.set_label('Power') plt.show()
def x_eemd(x): """ eemd变换 :param x: 代表采样数据[m,n],m代表每个周期的样本,n代表采样点 :return: 返回每个样本IMF分量,[m,IMF,n] """ eemd = EEMD() emd = eemd.EMD emd.extrema_detection = "parabol" for i in range(x.shape[0]): eIMFs = eemd.eemd(x[i]) print(eIMFs)
def main(): #load data e = exchange.Exchange('../lib/binance.db') start = int(datetime.datetime(2018, 7, 1).timestamp() * 1000) end = int(datetime.datetime(2019, 7, 1).timestamp() * 1000) print('Loading order data...') number_of_orders, prices = e.get_total_orders_ts('BTCUSDT', 60 * 60 * 1000, start, end) #hourly data print('done') buy_orders = np.array([b for s, b in number_of_orders]) sell_orders = np.array([s for s, b in number_of_orders]) t = [i for i, o in enumerate(buy_orders)] eemd = EEMD() emd = eemd.EMD eIMFs = eemd.eemd(buy_orders - sell_orders) n = eIMFs.shape[0] fig, axs = plt.subplots(n + 3, figsize=(12,9), sharex=True) axs[0].plot(prices) axs[0].set_ylabel('Price') axs[1].plot(buy_orders - sell_orders, color='g') axs[1].set_ylabel('Orders - (Buy - sell)') axs[2].plot(calculate_returns(prices)) for i in range(n): axs[i + 3].plot(eIMFs[i], color='g') axs[i + 3].set_ylabel('eIMF ' + str(i + 1)) plt.xlabel("Time /days") #plt.tight_layout() plt.show()
def eemd(signal): """ eemd分解 :param signal:采样信号 :return: """ # Assign EEMD to `eemd` variable eemd = EEMD() # Say we want detect extrema using parabolic method emd = eemd.EMD emd.extrema_detection = "parabol" # Execute EEMD on S eIMFs = eemd.eemd(S) return eIMFs
def test_eemd_ensemble_stats(self): T = np.linspace(0, 2 * np.pi, 100) S = np.sin(T) + 3 * np.sin(3 * T + 0.1) + 0.2 * (T + 0.5) * (T - 2) eemd = EEMD(trials=20, separate_trends=True) eIMFs = eemd(S) self.assertEqual(type(eemd.all_imfs), dict, "All imfs are stored as a dict") self.assertTrue(np.all(eIMFs == eemd.ensemble_mean()), "eIMFs are the mean over ensemble") self.assertEqual(eemd.ensemble_count(), [len(imfs) for imfs in eemd.all_imfs.values()]) self.assertEqual(type(eemd.ensemble_std()), np.ndarray, "Ensemble std exists and it's a numpy array")
def test_eemd_passingCustomEMD(self): spline_kind = "linear" params = {"spline_kind": spline_kind} eemd = EEMD() self.assertFalse(eemd.EMD.spline_kind==spline_kind, "Not"+self.cmp_msg(eemd.EMD.spline_kind, spline_kind)) from PyEMD import EMD emd = EMD(**params) eemd = EEMD(ext_EMD=emd) self.assertTrue(eemd.EMD.spline_kind==spline_kind, self.cmp_msg(eemd.EMD.spline_kind, spline_kind))
def test_default_call_EEMD(): T = np.arange(50) S = np.cos(T * 0.1) max_imf = 2 eemd = EEMD() eemd(S, T, max_imf)
def Plot_IMF(obs, mod, site_id): print('Process on IMF ' + 'No.' + str(site_id) + '!') data = (obs.extractDatasites(lat=obs.lat, lon=obs.lat)).data[:, site_id] time = mod.time[~data.mask] y = (mod.extractDatasites(lat=obs.lat, lon=obs.lat)).data[:, site_id] time_y = mod.time[~y.mask] d_mod = [] d_mod.append(y) fig1 = plt.figure(figsize=(4 * (len(d_mod) + 1), 8)) fig2 = plt.figure(figsize=(4 * (len(d_mod) + 1), 8)) fig3 = plt.figure(figsize=(5, 5)) fig4 = plt.figure(figsize=(5, 5)) fig1.subplots_adjust(wspace=0.5, hspace=0.3) fig2.subplots_adjust(wspace=0.5, hspace=0.3) eemd = EEMD(trials=5) imfs = eemd.eemd(data.compressed()) fig3, freq = hht(data.compressed(), imfs, time, 1, fig3) if len(imfs) >= 1: fig1 = plot_imfs(data.compressed(), imfs, time_samples=time, fig=fig1, no=1, m=len(d_mod)) fig2 = plot_frequency(data.compressed(), freq.T, time_samples=time, fig=fig2, no=1, m=len(d_mod)) imfs2 = eemd.eemd(y.compressed()) fig4, freq2 = hht(y.compressed(), imfs2, time_y, 1, fig4) if len(imfs) >= 1: fig1 = plot_imfs(y.compressed(), imfs2, time_samples=time_y, fig=fig1, no=2, m=len(d_mod)) fig2 = plot_frequency(y.compressed(), freq2.T, time_samples=time_y, fig=fig2, no=2, m=len(d_mod))
def eemd_decompose(a, t): eemd = EEMD(trials=200, noise_width=0.4)(a) eimfs, res = eemd[:-1], eemd[-1] #这的参数有问题!!!!!!!!!!!!!!!!!!!!! vis = Visualisation() vis.plot_imfs(imfs=eimfs, residue=res, t=t, include_residue=True) vis.plot_instant_freq(t, imfs=eimfs) # vis.show() return eimfs, res
def find_interval(signal, fs, imf_no=1): """ Compute the interval setting for the TIV. Calculating a hilbert transform from the instrinct mode functions (imfs). This is based on the hilbert-huang transform assuming non-stationarity of the given dataset. The function returns a suggested interval (most powerful frequency) based on the weighted average. The weights are the calculated instantaneous energies. Parameters ---------- signal: 1d np.ndarray a one dimensional array which contains the brightness temperature (perturbation) of one pixel over time. fs: int the fps which was used to record the imagery imf_no: int (default 1) The imf which will be used to calculate the interval on. IMF 1 is the one with the highest frequency. Returns ------- recommended_interval : float The found most powerful interval in float. Needs rounding to the next int. """ eemd = EEMD() imfs = eemd.eemd(signal) imf = imfs[imf_no - 1, :] sig = hilbert(imf) energy = np.square(np.abs(sig)) phase = np.arctan2(sig.imag, sig.real) omega = np.gradient(np.unwrap(phase)) omega = fs / (2 * math.pi) * omega #omegaIdx = np.floor((omega-F[0])/FResol)+1; #freqIdx = 1/omegaIdx; insf = omega inse = energy rel_inse = inse / np.nanmax(inse) insf_weigthed_mean = np.average(insf, weights=rel_inse) insp = 1 / insf_weigthed_mean recommended_interval = np.round(fs * insp, 1) gc.collect() return (recommended_interval)
def ee(data, drawflag): data.shape = (len(data),) x = np.linspace(1, len(data), len(data)) eemd = EEMD() # Say we want detect extrema using parabolic method emd = eemd.EMD emd.extrema_detection = "parabol" print(colored("decomposing - EEmd mode...", 'green')) imfs = eemd.eemd(data, x) if drawflag == 1: size = imfs.shape plt.figure(figsize=(20, 18)) for loop in range(1, size[0]+1): plt.subplot(size[0], 1, loop) plt.plot(x, imfs[loop-1]) plt.title(loop) plt.show() return imfs
def test_separate_trends(self): T = np.linspace(0, 2 * np.pi, 100) S = np.sin(T) + 3 * np.sin(3 * T + 0.1) + 0.2 * (T + 0.5) * (T - 2) eemd = EEMD(trials=20, separate_trends=True) eIMFs = eemd(S) for imf in eIMFs[:-1]: self.assertLess(abs(imf.mean()), 0.5) self.assertGreaterEqual(eIMFs[-1].mean(), 1)
def emd(signal): emd_cls = EEMD() imfs = emd_cls(signal) vkur = np.zeros(len(signal)) temp = [imf for imf in imfs if stats.kurtosis(imf) > 0] for imf in temp: vkur += imf hbSignal = abs(fftpack.hilbert(vkur)) return hbSignal
def test_eemd_noiseSeed(self): T = np.linspace(0, 1, 100) S = np.sin(2 * np.pi * T + 4**T) + np.cos((T - 0.4)**2) # Compare up to machine epsilon cmpMachEps = lambda x, y: np.abs(x - y) <= 2 * np.finfo(x.dtype).eps config = {"processes": 1} eemd = EEMD(trials=10, **config) # First run random seed eIMF1 = eemd(S) # Second run with defined seed, diff than first eemd.noise_seed(12345) eIMF2 = eemd(S) # Extremly unlikely to have same seed, thus different results msg_false = "Different seeds, expected different outcomes" if eIMF1.shape == eIMF2.shape: self.assertFalse(np.all(cmpMachEps(eIMF1, eIMF2)), msg_false) # Third run with same seed as with 2nd eemd.noise_seed(12345) eIMF3 = eemd(S) # Using same seeds, thus expecting same results msg_true = "Used same seed, expected same results" self.assertTrue(np.all(cmpMachEps(eIMF2, eIMF3)), msg_true)
def emdT(signal, t): from PyEMD import EEMD import numpy as np import pylab as plt # Define signal # Assign EEMD to `eemd` variable eemd = EEMD() # Say we want detect extrema using parabolic method emd = eemd.EMD emd.extrema_detection = "simple" # Execute EEMD on S S = signal[0][:] S = S[20000:25000] t = t[20000:25000] eIMFs = eemd.eemd(S, t) nIMFs = eIMFs.shape[0] # Plot results plt.figure(figsize=(20, 12)) plt.subplot(nIMFs + 1, 1, 1) plt.subplots_adjust(hspace=0.01) plt.xticks([]) plt.plot(t, S, color='black') for n in range(nIMFs): if n < 7: plt.subplot(nIMFs + 1, 1, n + 2) plt.plot(t, eIMFs[n], color='black') plt.ylabel("eIMF %i" % (n + 1)) plt.locator_params(axis='y', nbins=2) plt.xticks([]) elif n == 7: plt.subplot(nIMFs + 1, 1, n + 2) plt.plot(t, eIMFs[n], color='black') plt.ylabel("eIMF %i" % (n + 1)) plt.locator_params(axis='y', nbins=2) plt.xlabel("Time [s]") plt.show()
def prepare_data(): con = engine.connect() # con.execute("truncate DOdataPrecictOnly") # con.execute("INSERT INTO DOdataPrecictOnly(Date,`Dissolved Oxygen`) ( SELECT Date,`Dissolved Oxygen` FROM DOdata order by Date ASC)") rv = con.execute("select `Dissolved Oxygen` from DOdataPrecictOnly") do = [] for i in rv: print(i) do.append(i[0]) DO = [] for i in range(0, len(do)): DO.append([do[i]]) scaler_DO = MinMaxScaler(feature_range=(0, 1)) DO = scaler_DO.fit_transform(DO) # DO = isolutionforest(DO) eemd = EEMD() eemd.noise_seed(12345) imfs = eemd.eemd(DO.reshape(-1), None, 8) con.close() return imfs, scaler_DO
def test_eemd_unsupportedNoiseKind(self): noise_kind = "whoever_supports_this_is_wrong" eemd = EEMD(noise_kind=noise_kind) with self.assertRaises(ValueError): eemd.generate_noise(1., 100)
from PyEMD import EEMD import numpy as np import pylab as plt # Define signal t = np.linspace(0, 1, 200) sin = lambda x,p: np.sin(2*np.pi*x*t+p) S = 3*sin(18,0.2)*(t-0.2)**2 S += 5*sin(11,2.7) S += 3*sin(14,1.6) S += 1*np.sin(4*2*np.pi*(t-0.8)**2) S += t**2.1 -t # Assign EEMD to `eemd` variable eemd = EEMD() # Say we want detect extrema using parabolic method emd = eemd.EMD emd.extrema_detection="parabol" # Execute EEMD on S eIMFs = eemd.eemd(S, t) nIMFs = eIMFs.shape[0] # Plot results plt.figure(figsize=(12,9)) plt.subplot(nIMFs+1, 1, 1) plt.plot(t, S, 'r') for n in range(nIMFs):