def estimate_trend(self, time_series_x: np.ndarray, time_series_y: np.ndarray): # Extract imfs and residue emd = EMD() emd.emd(time_series_y) imfs, res = emd.get_imfs_and_residue() return imfs[-1]
def test_single_imf(self): """ Input is IMF. Expecint single shifting. """ max_diff = lambda a,b: np.max(np.abs(a-b)) emd = EMD() emd.FIXE_H = 2 t = np.arange(0, 1, 0.001) c1 = np.cos(4*2*np.pi*t) # 2 Hz S = c1.copy() # Input - linear function f(t) = sin(2Hz t) # import pdb; pdb.set_trace() imfs = emd.emd(S, t) self.assertEqual(imfs.shape[0], 1, "Expecting sin + trend") diff = np.allclose(imfs[0], c1) self.assertTrue(diff, "Expecting 1st IMF to be sin\nMaxDiff = " + str(max_diff(imfs[0],c1))) # Input - linear function f(t) = siin(2Hz t) + 2*t c2 = 5*(t+2) S += c2.copy() imfs = emd.emd(S, t) self.assertEqual(imfs.shape[0], 2, "Expecting sin + trend") diff1 = np.allclose(imfs[0], c1, atol=0.2) self.assertTrue(diff1, "Expecting 1st IMF to be sin\nMaxDiff = " + str(max_diff(imfs[0],c1))) diff2 = np.allclose(imfs[1], c2, atol=0.2) self.assertTrue(diff2, "Expecting 2nd IMF to be trend\nMaxDiff = " + str(max_diff(imfs[1],c2)))
def test_different_length_input(self): T = np.arange(20) S = np.random.random(len(T)+7) emd = EMD() with self.assertRaises(ValueError): emd.emd(S, T)
def test_different_length_input(self): T = np.arange(20) S = np.random.random(len(T) + 7) emd = EMD() with self.assertRaises(ValueError): emd.emd(S, T)
def test_unsupporter_spline(self): emd = EMD() emd.spline_kind = "waterfall" S = np.random.random(20) with self.assertRaises(ValueError): emd.emd(S)
def test_instantiation2(self): t = np.linspace(0, 1, 50) S = t + np.cos(np.cos(4. * t**2)) emd = EMD() emd.emd(S, t) imfs, res = emd.get_imfs_and_residue() vis = Visualisation(emd) assert (vis.imfs == imfs).all() assert (vis.residue == res).all()
def Inst_freq(peeled_seq, fs=4000): t = np.arange(0, 1, 1 / fs) # print(len(t)) emd = EMD() emd.emd(peeled_seq) imfs, res = emd.get_imfs_and_residue() vis = Visualisation(emd) imfs_inst_freqs = vis._calc_inst_freq(imfs, t, order=False, alpha=None) return imfs_inst_freqs
def test_check_imfs5(self): t = np.linspace(0, 1, 50) S = t + np.cos(np.cos(4. * t**2)) emd = EMD() emd.emd(S, t) imfs, res = emd.get_imfs_and_residue() vis = Visualisation(emd) imfs2, res2 = vis._check_imfs(imfs, res, False) assert (imfs == imfs2).all() assert (res == res2).all()
def get_same_shaped_imfs(signal): emd = EMD() try: imfs_signal = emd.emd(signal.numpy(), max_imf=12) except AttributeError: imfs_signal = emd.emd(signal, max_imf=12) if imfs_signal.shape[0] > 12: imfs_signal = imfs_signal[:12, :] new_imfs = np.zeros((12, signal.shape[0])) new_imfs[:imfs_signal.shape[0], :] = imfs_signal return new_imfs
def emd_decompose(a, t): emd = EMD() emd.emd(a) imfs, res = emd.get_imfs_and_residue() plt.plot(t, a) plt.title('origin sequence') vis = Visualisation(emd) vis.plot_imfs(t=t) vis.plot_instant_freq(t) vis.show() plt.show() return imfs, res
def Visualing(peeled_seq, fs=4000): t = np.arange(0, 1, 1 / fs) # print(len(t)) emd = EMD() emd.emd(peeled_seq) imfs, res = emd.get_imfs_and_residue() vis = Visualisation(emd) # Create a plot with all IMFs and residue vis.plot_imfs(imfs=imfs, residue=res, t=t, include_residue=True) # Create a plot with instantaneous frequency of all IMFs vis.plot_instant_freq(t, imfs=imfs) # Show both plots vis.show()
def empirical_mode_decomposition(date_ini, ts_ini): """ :param ts_ini: the raw data to be decomposed :return: the decomposed time series """ # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//the wavelet tranform //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # A2, D2, D1 = pywt.wavedec(stress_ini.ravel(), 'db5', level=2) # print(stress_ini.shape) # print(D2.shape, D1.shape) # cow = [A2, D2, D1] # raw_data = pywt.waverec(cow, 'db5') # plt.style.use('seaborn-pastel') # fig = plt.figure(figsize=(8, 6)) # ax = fig.add_subplot(111) # ax.plot(stress_ini) # ax.plot(A2) # ax.plot(D2) # ax.plot(D1) # ax.plot(raw_data+0.1) # plt.show() # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//the empirical mode decomposition //~~~~~~~~~~~~~~~~~~~~~ emd = EMD() emd.emd(ts_ini.ravel()) imfs, res = emd.get_imfs_and_residue() # Plot results # N = imfs.shape[0] + 2 # plt.style.use('seaborn-pastel') # plt.figure(figsize=(15, 20)) # plt.subplot(N, 1, 1) # plt.plot(date_ini, ts_ini, 'r') # plt.title("Raw data") # plt.xlabel('shear stress, ' + r'$\tau$(MPa)') # # for n, imf in enumerate(imfs): # plt.subplot(N, 1, n + 2) # plt.plot(date_ini, imf, 'g') # plt.title("IMF " + str(n + 1)) # plt.xlabel("Time [0.1s]") # # plt.subplot(N, 1, N) # plt.plot(date_ini, res, 'b') # plt.title("residue") # plt.xlabel('shear stress, ' + r'$\tau$(MPa)') # plt.tight_layout() # plt.savefig('simple_example', dpi=600, bbox_inches='tight') # plt.show() return imfs, res
class EmdTransformer(object): """Empirical Mode Decomposition""" def __init__(self, ensemble=False, **kwargs): self.ensemble = ensemble if ensemble: self.emd_obj = EEMD(**kwargs) else: self.emd_obj = EMD(**kwargs) def fit_transform(self, data, **kwargs): if isinstance(data, pd.DataFrame): data = data.values else: assert isinstance(data, np.ndarray) assert len(data.shape) == 2 imfs = [] for col in range(data.shape[1]): if self.ensemble: IMFs = self.emd_obj.eemd(data[:, col], **kwargs) else: IMFs = self.emd_obj.emd(data[:, col], **kwargs) imfs.append(IMFs.T) return np.concatenate(imfs, axis=1) def inverse_transform(self, **kwargs): raise NotImplementedError
def test_emd_FIXE(self): T = np.linspace(0, 1, 100) c = np.sin(9 * 2 * np.pi * T) offset = 4 S = c + offset emd = EMD() # Default state: converge self.assertTrue(emd.FIXE == 0) self.assertTrue(emd.FIXE_H == 0) # Set 1 iteration per each sift, # same as removing offset FIXE = 1 emd.FIXE = FIXE # Check flags correctness self.assertTrue(emd.FIXE == FIXE) self.assertTrue(emd.FIXE_H == 0) # Extract IMFs IMFs = emd.emd(S) # Check that IMFs are correct self.assertTrue(np.allclose(IMFs[0], c)) self.assertTrue(np.allclose(IMFs[1], offset))
def test_emd_FIXE(self): T = np.linspace(0, 1, 100) c = np.sin(9*2*np.pi*T) offset = 4 S = c + offset emd = EMD() # Default state: converge self.assertTrue(emd.FIXE==0) self.assertTrue(emd.FIXE_H==0) # Set 1 iteration per each sift, # same as removing offset FIXE = 1 emd.FIXE = FIXE # Check flags correctness self.assertTrue(emd.FIXE==FIXE) self.assertTrue(emd.FIXE_H==0) # Extract IMFs IMFs = emd.emd(S) # Check that IMFs are correct self.assertTrue(np.allclose(IMFs[0], c)) self.assertTrue(np.allclose(IMFs[1], offset))
def test_calc_instant_phase2(self): t = np.linspace(0, 1, 50) S = t + np.cos(np.cos(4. * t**2)) emd = EMD() imfs = emd.emd(S, t) vis = Visualisation() phase = vis._calc_inst_phase(imfs, 0.4) assert len(imfs) == len(phase)
def test_calc_instant_phase3(self): t = np.linspace(0, 1, 50) S = t + np.cos(np.cos(4. * t**2)) emd = EMD() imfs = emd.emd(S, t) vis = Visualisation() with self.assertRaises(AssertionError): phase = vis._calc_inst_phase(imfs, 0.8)
def test_calc_instant_freq(self): t = np.linspace(0, 1, 50) S = t + np.cos(np.cos(4. * t**2)) emd = EMD() imfs = emd.emd(S, t) vis = Visualisation() freqs = vis._calc_inst_freq(imfs, t, False, None) assert imfs.shape == freqs.shape
def IMFs(self, win): temp = self.data_freq * int(1 / self.gap) self.price = self.PriceList[-60 / int(self.gap):-1] s = self.price emd = EMD() IMFs = emd.emd(s) r = IMFs[-1] b = np.std(s - r) self.r = math.log(b / a)
def imff(self): temp = self.data_freq * int(1 / self.gap) self.price = self.PriceList[-int(self.data_freq / self.gap):-1] s = np.array(self.price) emd = EMD() IMFs = emd.emd(s) r = IMFs[-1] a = np.std(r) b = np.std(s - r) self.r = math.log(b / a)
def dme_function(lista_para_ejecutar): nueva_list = lista_para_ejecutar new_data =[] for item in nueva_list: new_data.append(float(item)) #x = np.linspace(0, 10, len(lista_para_ejecutar)) signal = np.array(new_data) emd = EMD() IMFS = emd.emd(signal) return IMFS
def hes2(args): n = 10000 t = np.arange(0, n/args.fs, 1/args.fs) S = args.singled_out[-1, 0:n] args.temp_add = 'emd_raw' show_signal(S, args) emd = EMD() emd.emd(S) imfs, res = emd.get_imfs_and_residue() # In general: # components = EEMD()(S) # imfs, res = components[:-1], components[-1] vis = Visualisation() vis.plot_imfs(imfs=imfs, residue=res, t=t, include_residue=True) vis.plot_instant_freq(t, imfs=imfs) vis.show() return 0
def test_max_iteration_flag(self): S = np.random.random(200) emd = EMD() emd.MAX_ITERATION = 10 emd.FIXE = 20 imfs = emd.emd(S) # There's not much to test, except that it doesn't fail. # With low MAX_ITERATION value for random signal it's # guaranteed to have at least 2 imfs. self.assertTrue(imfs.shape[0]>1)
def test_trend(self): """ Input is trend. Expeting no shifting process. """ emd = EMD() t = np.arange(0, 1, 0.01) S = 2*t # Input - linear function f(t) = 2*t imfs = emd.emd(S, t) self.assertEqual(imfs.shape[0], 1, "Expecting single IMF") self.assertTrue(np.allclose(S, imfs[0]))
def test_trend(self): """ Input is trend. Expeting no shifting process. """ emd = EMD() t = np.arange(0, 1, 0.01) S = 2 * t # Input - linear function f(t) = 2*t IMF = emd.emd(S, t) self.assertEqual(IMF.shape[0], 1, "Expecting single IMF") self.assertTrue(np.allclose(S, IMF[0]))
def ver_dme(): array1year = [] array1month = [] array2 = [] #limpieza de datos for line in open(path): array1year.append(line[0:4]) array1month.append(line[4:6]) if line[7] == '-': array2.append(line[7:]) else: array2.append(line[7:]) lista = [] lista2 = [] listaGeneral = [] for valor in array2: lista.append(valor.rstrip('\n')) #print(lista) for sal in range(len(lista)): lista2.append(array1year[sal] + '-' + array1month[sal]) #print(lista2) #creación del dataframe listaGeneral = dict(zip(lista2[1:], lista[1:])) tupla = listaGeneral.items() df = pd.DataFrame(list(tupla)) df.columns = ["fecha", "valor"] global my_graph my_graph = df["valor"].astype(float) global new_list new_list = lista[1:] dataoni = [] for item in new_list: dataoni.append(float(item)) signal = np.array(dataoni) emd = EMD() IMFS = emd.emd(signal) funcion = tk.StringVar(framedme) funcion.set("Seleccione la Descomposición") opciones = [] for line in range(len(IMFS)): opciones.append(line) #print (line) global dropselect dropselect = ttk.OptionMenu(framedme, funcion, *opciones) dropselect.pack(padx=5, pady=5, ipadx=5, ipady=5)
def get_data(self): x_train, y_train = [], [] for k in self.list_npz_files(): with np.load(k) as f: data = f["x"] labels = f["y"] labels = np.expand_dims(labels,axis=1) for i in range(len(data)): a = np.zeros((5,)) a[labels[i]] = 1 a = np.reshape(a, (None,5)) x_train.append(EMD.emd(data[i])) y_train.append(a) return np.asarray(x_train), np.asarray(y_train)
def emd_filter(raw_time_series, threshold=0.5): """ This method is required by all the bar types and is used to create the desired bars. :params 1. raw_time_series: (time series in numpy array) 2. threshold: (float number) it denotes how much low-frequency components will be kept. It should be in the range of [0, 1] :return: the same-length data """ # initalize the EMD emd = EMD() # apply the EMD decomposition imfs = emd.emd(raw_time_series) # save the low frequent components new_time_series = _filter_imfs(imfs, threshold) return new_time_series
def emdLSTM(dataset): emd = EMD() IMFs = emd.emd(dataset) print(type(IMFs)) [rows, columns] = IMFs.shape yhatResult = 0 for n, imf in enumerate(IMFs): tempDataSet = imf #print('--------------------------------------') #myDataSet, myScalar, myMinValue = normalizeData(tempDataSet) X_train, y_train, X_test, y_test = getTrainAndTest(tempDataSet) yhat = trainAndPred(X_train, y_train, X_test) #pred_y, _ = returnNormal(myScalar, myMinValue, yhat, y_test) #print(yhat) yhatResult = yhat + yhatResult print(yhatResult) return yhatResult
def test_emd_default(self): T = np.linspace(0, 2, 200) c1 = 1 * np.sin(11 * 2 * np.pi * T + 0.1) c2 = 11 * np.sin(1 * 2 * np.pi * T + 0.1) offset = 9 S = c1 + c2 + offset emd = EMD(spline_kind='akima') imfs = emd.emd(S, T) self.assertTrue(imfs.shape[0] == 3) close_imfs1 = np.allclose(c1[2:-2], imfs[0, 2:-2], atol=0.2) self.assertTrue(close_imfs1) close_imfs2 = np.allclose(c2[2:-2], imfs[1, 2:-2], atol=0.21) self.assertTrue(close_imfs2) close_offset = np.allclose(offset, imfs[2, 1:-1], atol=0.5) self.assertTrue(close_offset)
def test_emd_default(self): T = np.linspace(0, 2, 200) c1 = 1 * np.sin(11 * 2 * np.pi * T + 0.1) c2 = 11 * np.sin(1 * 2 * np.pi * T + 0.1) offset = 9 S = c1 + c2 + offset emd = EMD() IMFs = emd.emd(S, T) self.assertTrue(IMFs.shape[0] == 3) closeIMF1 = np.allclose(c1[1:-1], IMFs[0, 1:-1], atol=0.5) self.assertTrue(closeIMF1) closeIMF2 = np.allclose(c2[1:-1], IMFs[1, 1:-1], atol=0.5) self.assertTrue(closeIMF2) closeOffset = np.allclose(offset, IMFs[2, 1:-1], atol=0.5) self.assertTrue(closeOffset)
def test_emd_default(self): T = np.linspace(0, 2, 200) c1 = 1*np.sin(11*2*np.pi*T+0.1) c2 = 11*np.sin(1*2*np.pi*T+0.1) offset = 9 S = c1 + c2 + offset emd = EMD(spline_kind='akima') imfs = emd.emd(S, T) self.assertTrue(imfs.shape[0]==3) close_imfs1 = np.allclose(c1[2:-2], imfs[0,2:-2], atol=0.21) self.assertTrue(close_imfs1) close_imfs2 = np.allclose(c2[2:-2], imfs[1,2:-2], atol=0.24) diff = np.abs(c2[2:-2] - imfs[1,2:-2]) self.assertTrue(close_imfs2) close_offset = np.allclose(offset, imfs[2,1:-1], atol=0.5) self.assertTrue(close_offset)
def test_emd_FIXEH(self): T = np.linspace(0, 2, 200) c1 = 1 * np.sin(11 * 2 * np.pi * T + 0.1) c2 = 11 * np.sin(1 * 2 * np.pi * T + 0.1) offset = 9 S = c1 + c2 + offset emd = EMD() # Default state: converge self.assertTrue(emd.FIXE == 0) self.assertTrue(emd.FIXE_H == 0) # Set 5 iterations per each protoIMF FIXE_H = 6 emd.FIXE_H = FIXE_H # Check flags correctness self.assertTrue(emd.FIXE == 0) self.assertTrue(emd.FIXE_H == FIXE_H) # Extract IMFs IMFs = emd.emd(S) # Check that IMFs are correct self.assertTrue(IMFs.shape[0] == 3) closeIMF1 = np.allclose(c1[1:-1], IMFs[0, 1:-1], atol=0.5) self.assertTrue(closeIMF1) self.assertTrue(np.allclose(c1, IMFs[0], atol=1.)) closeIMF2 = np.allclose(c2[1:-1], IMFs[1, 1:-1], atol=0.5) self.assertTrue(closeIMF2) self.assertTrue(np.allclose(c2, IMFs[1], atol=1.)) closeOffset = np.allclose(offset, IMFs[2, 1:-1], atol=0.5) self.assertTrue(closeOffset) self.assertTrue(np.allclose(IMFs[1, 1:-1], c2[1:-1], atol=0.5)) closeOffset = np.allclose(offset, IMFs[2, 1:-1], atol=0.5) self.assertTrue(closeOffset)
def test_emd_FIXEH(self): T = np.linspace(0, 2, 200) c1 = 1*np.sin(11*2*np.pi*T+0.1) c2 = 11*np.sin(1*2*np.pi*T+0.1) offset = 9 S = c1 + c2 + offset emd = EMD() # Default state: converge self.assertTrue(emd.FIXE==0) self.assertTrue(emd.FIXE_H==0) # Set 5 iterations per each protoIMF FIXE_H = 6 emd.FIXE_H = FIXE_H # Check flags correctness self.assertTrue(emd.FIXE==0) self.assertTrue(emd.FIXE_H==FIXE_H) # Extract IMFs imfs = emd.emd(S) # Check that IMFs are correct self.assertTrue(imfs.shape[0]==3) close_imf1 = np.allclose(c1[2:-2], imfs[0,2:-2], atol=0.2) self.assertTrue(close_imf1) self.assertTrue(np.allclose(c1, imfs[0], atol=1.)) close_imf2 = np.allclose(c2[2:-2], imfs[1,2:-2], atol=0.21) self.assertTrue(close_imf2) self.assertTrue(np.allclose(c2, imfs[1], atol=1.)) close_offset = np.allclose(offset, imfs[2,2:-2], atol=0.1) self.assertTrue(close_offset) close_offset = np.allclose(offset, imfs[2,1:-1], atol=0.5) self.assertTrue(close_offset)
def EMDfilterData(data, samplingRate, lowerFreqCutoff=0.28, upperFreqCutoff=20): ''' Inputs: Data: numpy arrray with one-dimensional data Outputs: filteredData: numpy array of data after filtering ''' emd = EMD() IMFs = emd.emd(data) outputSignal = numpy.zeros_like(data) for imf in range(IMFs.shape[0]): imfFrequency = getFreqDataOfIMF(IMFs[imf, :]) if imfFrequency > upperFreqCutoff: pass elif imfFrequency < lowerFreqCutoff: pass else: outputSignal += IMFs[imf, :] return (outputSignal)