def test_default_call_EMD(): T = np.arange(50) S = np.cos(T * 0.1) max_imf = 2 emd = emd() emd(S, T, max_imf)
def test_emd_passArgsViaDict(self): FIXE = 10 params = {"FIXE": FIXE, "nothing": 0} # First test without initiation emd = emd() self.assertFalse(emd.FIXE == FIXE, "{} == {}".format(emd.FIXE, FIXE)) # Second: test with passing emd = emd(**params) self.assertTrue(emd.FIXE == FIXE, "{} == {}".format(emd.FIXE, FIXE))
def test_imfs_and_residue_accessor(self): S = np.random.random(200) emd = emd(**{"MAX_ITERATION": 10, "FIXE": 20}) all_imfs = emd(S, max_imf=3) imfs, residue = emd.get_imfs_and_residue() self.assertEqual(all_imfs.shape[0], imfs.shape[0] + 1, "Compare number of components") self.assertTrue(np.array_equal(all_imfs[:-1], imfs), "Shouldn't matter where imfs are from") self.assertTrue(np.array_equal(all_imfs[-1], residue), "Residue, if any, is the last row")
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_cubic(self): dtype = np.float64 emd = emd() emd.spline_kind = 'cubic' emd.DTYPE = dtype T = np.array([0, 1, 2, 3, 4], dtype=dtype) S = np.array([0, 1, -1, -1, 5], dtype=dtype) t = np.arange(9, dtype=dtype)/2. # TODO: Something weird with float32. # Seems to be SciPy problem. _t, s = emd.spline_points(t, np.array((T,S))) s_true = np.array([S[0], 1.203125, S[1], 0.046875, \ S[2], -1.515625, S[3], 1.015625, S[4]], dtype=dtype) self.assertTrue(np.allclose(s, s_true, atol=0.01), "Comparing cubic") T = T[:-2].copy() S = S[:-2].copy() t = np.arange(5, dtype=dtype)/2. _t, s3 = emd.spline_points(t, np.array((T,S))) s3_true = np.array([S[0], 0.78125, S[1], 0.28125, S[2]], dtype=dtype) self.assertTrue(np.allclose(s3, s3_true), "Compare cubic 3pts")
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_akima(self): dtype = np.float32 emd = emd() emd.spline_kind = 'akima' emd.DTYPE = dtype # Test error: len(X)!=len(Y) with self.assertRaises(ValueError): akima(np.array([0]), np.array([1,2]), np.array([0,1,2])) # Test error: any(dt) <= 0 with self.assertRaises(ValueError): akima(np.array([1,0,2]), np.array([1,2]), np.array([0,1,2])) with self.assertRaises(ValueError): akima(np.array([0,0,2]), np.array([1,2]), np.array([0,1,1])) # Test for correct responses T = np.array([0, 1, 2, 3, 4], dtype) S = np.array([0, 1, -1, -1, 5], dtype) t = np.array([i/2. for i in range(9)], dtype) _t, s = emd.spline_points(t, np.array((T,S))) s_true = np.array([S[0], 0.9125, S[1], 0.066666, S[2],-1.35416667, S[3], 1.0625, S[4]], dtype) self.assertTrue(np.allclose(s_true, s), "Comparing akima with true") s_np = akima(np.array(T), np.array(S), np.array(t)) self.assertTrue(np.allclose(s, s_np), "Shouldn't matter if with numpy")
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_wrong_extrema_detection_type(self): emd = emd() emd.extrema_detection = "very_complicated" t = np.arange(10) s = np.array([-1, 0, 1, 0, -1, 0, 3, 0, -9, 0]) with self.assertRaises(ValueError): find_extrema(t, s)
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_slinear(self): dtype = np.float64 emd = emd() emd.spline_kind = 'slinear' emd.DTYPE = dtype T = np.array([0, 1, 2, 3, 4], dtype=dtype) S = np.array([0, 1, -1, -1, 5], dtype=dtype) t = np.arange(9, dtype=dtype)/2. _t, s = emd.spline_points(t, np.array((T,S))) s_true = np.array([S[0], 0.5, S[1], 0, \ S[2], -1, S[3], 2, S[4]], dtype=dtype) self.assertTrue(np.allclose(s, s_true), "Comparing SLinear")
def test_ceemdan_passingCustomEMD(self): spline_kind = "linear" params = {"spline_kind": spline_kind} ceemdan = ceemdan() self.assertFalse(ceemdan.EMD.spline_kind==spline_kind, "Not"+self.cmp_msg(ceemdan.EMD.spline_kind, spline_kind)) from EMD import emd emd = emd(**params) ceemdan = ceemdan(ext_EMD=emd) self.assertTrue(ceemdan.EMD.spline_kind==spline_kind, self.cmp_msg(ceemdan.EMD.spline_kind, spline_kind))
def __init__(self, trials=100, epsilon=0.005, ext_EMD=None, parallel=True, **config): """ Configuration can be passed through config dictionary. For example, updating threshold would be through: # >>> config = {"range_thr": 0.001, "total_power_thr": 0.01} # >>> EMD = EMD(**config) """ # Ensemble constants self.trials = trials self.epsilon = epsilon self.all_noise_std = np.zeros(self.trials) self.beta_progress = True # Scale noise by std self.random = np.random.RandomState() self.noise_kind = "normal" self.parallel = parallel self.all_noise_EMD = [] if ext_EMD is None: from EMD import emd self.EMD = emd() else: self.EMD = ext_EMD self.range_thr = 0.01 self.total_power_thr = 0.05 # By default (None) Pool spawns #processes = #CPU if parallel: processes = None if "processes" not in config else config[ "processes"] self.pool = Pool(processes=processes) # Update based on options for key in config.keys(): if key in self.__dict__.keys(): self.__dict__[key] = config[key] elif key in self.EMD.__dict__.keys(): self.EMD.__dict__[key] = config[key]
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 EMD 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_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_find_extrema_parabol(self): """ Simple test for extrema. """ emd = emd() emd.extrema_detection = "parabol" t = np.arange(10) s = np.array([-1, 0, 1, 0, -1, 0, 3, 0, -9, 0]) expMaxPos = [2, 6] expMaxVal = [1, 3] expMinPos = [4, 8] expMinVal = [-1, -9] maxPos, maxVal, minPos, minVal, nz = find_extrema(t, s) self.assertEqual(maxPos.tolist(), expMaxPos) self.assertEqual(maxVal.tolist(), expMaxVal) self.assertEqual(minPos.tolist(), expMinPos) self.assertEqual(minVal.tolist(), expMinVal)
def test_incorrectExtremaDetectionSetup(self): extrema_detection = "bubble_gum" # Sanity check emd = emd() self.assertFalse(emd.extrema_detection == extrema_detection) # Assign incorrect extrema_detection emd.extrema_detection = extrema_detection self.assertTrue(emd.extrema_detection == extrema_detection) T = np.arange(10) S = np.sin(T) max_pos, max_val = np.random.random((2, 3)) min_pos, min_val = np.random.random((2, 3)) # Check for Exception with self.assertRaises(ValueError): emd.mirror_extension_prepare_points(T, S, max_pos, max_val, min_pos, min_val)
def test_find_extrema_simple_repeat(self): """ Test what happens in /^^\ situation, i.e. when extremum is somewhere between two consecutive pts. """ emd = emd() emd.extrema_detection = "simple" t = np.arange(2, 13) s = np.array([-1, 0, 1, 1, 0, -1, 0, 3, 0, -9, 0]) expMaxPos = [4, 9] expMaxVal = [1, 3] expMinPos = [7, 11] expMinVal = [-1, -9] maxPos, maxVal, minPos, minVal, nz = find_extrema(t, s) self.assertEqual(maxPos.tolist(), expMaxPos) self.assertEqual(maxVal.tolist(), expMaxVal) self.assertEqual(minPos.tolist(), expMinPos) self.assertEqual(minVal.tolist(), expMinVal)
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 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_bound_extrapolation_simple(self): emd = emd() emd.extrema_detection = "simple" emd.nbsym = 1 emd.DTYPE = np.int64 S = [0, -3, 1, 4, 3, 2, -2, 0, 1, 2, 1, 0, 1, 2, 5, 4, 0, -2, -1] S = np.array(S) T = np.arange(len(S)) pp = emd.mirror_extension_prepare_points # There are 4 cases for both (L)eft and (R)ight ends. In case of left (L) bound: # L1) ,/ -- ext[0] is min, s[0] < ext[1] (1st max) # L2) / -- ext[0] is min, s[0] > ext[1] (1st max) # L3) ^. -- ext[0] is max, s[0] > ext[1] (1st min) # L4) \ -- ext[0] is max, s[0] < ext[1] (1st min) ## CASE 1 # L1, R1 -- no edge MIN & no edge MIN s = S.copy() t = T.copy() maxPos, maxVal, minPos, minVal, nz = find_extrema(t, s) # Should extrapolate left and right bounds maxExtrema, minExtrema = pp(t, s, \ maxPos, maxVal, minPos, minVal) self.assertEqual([-1, 3, 9, 14, 20], maxExtrema[0].tolist()) self.assertEqual([4, 4, 2, 5, 5], maxExtrema[1].tolist()) self.assertEqual([-4, 1, 6, 11, 17, 23], minExtrema[0].tolist()) self.assertEqual([-2, -3, -2, 0, -2, 0], minExtrema[1].tolist()) ## CASE 2 # L2, R2 -- edge MIN, edge MIN s = S[1:-1].copy() t = np.arange(s.size) maxPos, maxVal, minPos, minVal, nz = find_extrema(t, s) # Should extrapolate left and right bounds maxExtrema, minExtrema = pp(t, s, \ maxPos, maxVal, minPos, minVal) self.assertEqual([-2, 2, 8, 13, 19], maxExtrema[0].tolist()) self.assertEqual([4, 4, 2, 5, 5], maxExtrema[1].tolist()) self.assertEqual([0, 5, 10, 16], minExtrema[0].tolist()) self.assertEqual([-3, -2, 0, -2], minExtrema[1].tolist()) ## CASE 3 # L3, R3 -- no edge MAX & no edge MAX s = S[2:-3].copy() t = np.arange(s.size) maxPos, maxVal, minPos, minVal, nz = find_extrema(t, s) # Should extrapolate left and right bounds maxExtrema, minExtrema = pp(t, s, \ maxPos, maxVal, minPos, minVal) self.assertEqual([-5, 1, 7, 12, 17], maxExtrema[0].tolist()) self.assertEqual([2, 4, 2, 5, 2], maxExtrema[1].tolist()) self.assertEqual([-2, 4, 9, 15], minExtrema[0].tolist()) self.assertEqual([-2, -2, 0, 0], minExtrema[1].tolist()) ## CASE 4 # L4, R4 -- edge MAX & edge MAX s = S[3:-4].copy() t = np.arange(s.size) maxPos, maxVal, minPos, minVal, nz = find_extrema(t, s) # Should extrapolate left and right bounds maxExtrema, minExtrema = pp(t, s, \ maxPos, maxVal, minPos, minVal) self.assertEqual([0, 6, 11], maxExtrema[0].tolist()) self.assertEqual([4, 2, 5], maxExtrema[1].tolist()) self.assertEqual([-3, 3, 8, 14], minExtrema[0].tolist()) self.assertEqual([-2, -2, 0, 0], minExtrema[1].tolist())
def test_bound_extrapolation_parabol(self): emd = emd() emd.extrema_detection = "parabol" emd.nbsym = 1 emd.DTYPE = np.float64 S = [0, -3, 1, 4, 3, 2, -2, 0, 1, 2, 1, 0, 1, 2, 5, 4, 0, -2, -1] S = np.array(S) T = np.arange(len(S)) pp = emd.mirror_extension_prepare_points # There are 4 cases for both (L)eft and (R)ight ends. In case of left (L) bound: # L1) ,/ -- ext[0] is min, s[0] < ext[1] (1st max) # L2) / -- ext[0] is min, s[0] > ext[1] (1st max) # L3) ^. -- ext[0] is max, s[0] > ext[1] (1st min) # L4) \ -- ext[0] is max, s[0] < ext[1] (1st min) ## CASE 1 # L1, R1 -- no edge MIN & no edge MIN s = S.copy() t = T.copy() maxPos, maxVal, minPos, minVal, nz = find_extrema(t, s) # Should extrapolate left and right bounds maxExtrema, minExtrema = pp(t, s, \ maxPos, maxVal, minPos, minVal) maxExtrema = np.round(maxExtrema, decimals=3) minExtrema = np.round(minExtrema, decimals=3) self.assertEqual([-1.393, 3.25, 9, 14.25, 20.083], maxExtrema[0].tolist()) self.assertEqual([4.125, 4.125, 2, 5.125, 5.125], maxExtrema[1].tolist()) self.assertEqual([-4.31, 0.929, 6.167, 11, 17.167, 23.333], minExtrema[0].tolist()) self.assertEqual([-2.083, -3.018, -2.083, 0, -2.042, 0], minExtrema[1].tolist()) ## CASE 2 # L2, R2 -- edge MIN, edge MIN s = S[1:-1].copy() t = T[1:-1].copy() maxPos, maxVal, minPos, minVal, nz = find_extrema(t, s) # Should extrapolate left and right bounds maxExtrema, minExtrema = pp(t, s, \ maxPos, maxVal, minPos, minVal) maxExtrema = np.round(maxExtrema, decimals=3) minExtrema = np.round(minExtrema, decimals=3) self.assertEqual([-1.25, 3.25, 9, 14.25, 19.75], maxExtrema[0].tolist()) self.assertEqual([4.125, 4.125, 2, 5.125, 5.125], maxExtrema[1].tolist()) self.assertEqual([1, 6.167, 11, 17], minExtrema[0].tolist()) self.assertEqual([-3, -2.083, 0, -2], minExtrema[1].tolist()) ## CASE 3 # L3, R3 -- no edge MAX & no edge MAX s = S[2:-3].copy() t = T[2:-3].copy() maxPos, maxVal, minPos, minVal, nz = find_extrema(t, s) # Should extrapolate left and right bounds maxExtrema, minExtrema = pp(t, s, \ maxPos, maxVal, minPos, minVal) maxExtrema = np.round(maxExtrema, decimals=3) minExtrema = np.round(minExtrema, decimals=3) self.assertEqual([-2.5, 3.25, 9, 14.25, 19.5], maxExtrema[0].tolist()) self.assertEqual([2, 4.125, 2, 5.125, 2], maxExtrema[1].tolist()) self.assertEqual([0.333, 6.167, 11, 17.5], minExtrema[0].tolist()) self.assertEqual([-2.083, -2.083, 0, 0], minExtrema[1].tolist()) ## CASE 4 # L4, R4 -- edge MAX & edge MAX s = S[3:-4].copy() t = T[3:-4].copy() maxPos, maxVal, minPos, minVal, nz = find_extrema(t, s) # Should extrapolate left and right bounds maxExtrema, minExtrema = pp(t, s, \ maxPos, maxVal, minPos, minVal) maxExtrema = np.round(maxExtrema, decimals=3) minExtrema = np.round(minExtrema, decimals=3) self.assertEqual([3, 9, 14], maxExtrema[0].tolist()) self.assertEqual([4, 2, 5], maxExtrema[1].tolist()) self.assertEqual([-0.167, 6.167, 11, 17], minExtrema[0].tolist()) self.assertEqual([-2.083, -2.083, 0, 0], minExtrema[1].tolist())
# Author: Dawid Laszuk # Last update: 7/07/2017 from __future__ import division, print_function import numpy as np import pylab as plt from EMD import emd # Define signal t = np.linspace(0, 1, 200) s = np.cos(11 * 2 * np.pi * t * t) + 6 * t * t # Execute EMD on signal IMF = emd().emd(s, t) N = IMF.shape[0] + 1 # Plot results plt.subplot(N, 1, 1) plt.plot(t, s, 'r') plt.title("Input signal: $S(t)=cos(22\pi t^2) + 6t^2$") plt.xlabel("Time [s]") for n, imf in enumerate(IMF): plt.subplot(N, 1, n + 2) plt.plot(t, imf, 'g') plt.title("IMF " + str(n + 1)) plt.xlabel("Time [s]") plt.tight_layout() plt.savefig('simple_example') plt.show()
return phase # Define signal t = np.linspace(0, 1, 200) dt = t[1] - t[0] 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 # Compute IMFs with EMD emd = emd() imfs = emd(S, t) # Extract instantaneous phases and frequencies using Hilbert transform instant_phases = instant_phase(imfs) instant_freqs = np.diff(instant_phases) / (2 * np.pi * dt) # Create a figure consisting of 3 panels which from the top are the input signal, IMFs and instantaneous frequencies fig, axes = plt.subplots(3, figsize=(12, 12)) # The top panel shows the input signal ax = axes[0] ax.plot(t, S) ax.set_ylabel("Amplitude [arb. u.]") ax.set_title("Input signal")
filename = "s" + str(j + 1) + ".dat" s = open(process_name1 + filename, "rb") # 以bytes类型正常读取文件 print(process_name + filename) num = pickle.load(s, encoding="latin1") labels = num['labels'] num_list_Theta = numpy.zeros((32, 2560)) num_list_Alpha = numpy.zeros((32, 2560)) num_list_Beta = numpy.zeros((32, 2560)) num_list_Gamma = numpy.zeros((32, 2560)) for p in range(0, 32): Theta = num['Theta'][p] Alpha = num['Alpha'][p] Beta = num['Beta'][p] Gamma = num['Gamma'][p] imf1_Theta = emd(Theta) print(1) imf1_Alpha = emd(Alpha) print(2) imf1_Beta = emd(Beta) print(3) imf1_Gamma = emd(Gamma) print(4) for m in range(0, 2560): for n in range(1, len(imf1_Theta)): imf1_Theta[0][m] += imf1_Theta[n][m] print('Theta' + str(p)) for n in range(1, len(imf1_Alpha)): imf1_Alpha[0][m] += imf1_Alpha[n][m] print('Alpha' + str(p)) for n in range(1, len(imf1_Beta)):