👸🏼 ✋🏿 👨🏿‍🏫 तरंग विश्लेषण। भाग २ 👰🏽 🤨 🧕🏼

परिचय

यह प्रकाशन समय श्रृंखला के तरंग विश्लेषण पर चर्चा करता है। तरंगिका परिवर्तन का मुख्य विचार कई समय श्रृंखला की बारीकियों से मेल खाता है जो उनकी मुख्य विशेषताओं के समय में विकास को प्रदर्शित करता है - हार्मोनिक घटकों का औसत मूल्य, विचरण, अवधि, आयाम और चरण। ज्ञान के विभिन्न क्षेत्रों में अध्ययन किए गए अधिकांश प्रक्रियाओं में उपरोक्त विशेषताएं हैं।

इस प्रकाशन का उद्देश्य PyWavelets पुस्तकालय का उपयोग करके समय श्रृंखला के निरंतर तरंगिका परिवर्तन की विधि का वर्णन करना है।

थोड़ा सा इतिहास

XX सदी के उत्तरार्ध के 70 के दशक में भूभौतिकीविद् डी। मोर्लिक्स। मुझे भूकंपीय सेंसर से संकेतों के विश्लेषण की समस्या का सामना करना पड़ा जिसमें एक लंबी अवधि के लिए उच्च आवृत्ति घटक (भूकंपीय गतिविधि) और एक लंबी अवधि के लिए कम आवृत्ति वाले घटक (पृथ्वी की पपड़ी की शांत स्थिति) शामिल थे। विंडो फूरियर रूपांतरण आपको उच्च-आवृत्ति घटक या निम्न-आवृत्ति घटक का विश्लेषण करने की अनुमति देता है, लेकिन दोनों घटकों को एक बार में नहीं।

इसलिए, एक विश्लेषण विधि प्रस्तावित की गई जिसमें कम आवृत्तियों के लिए विंडो फ़ंक्शन की चौड़ाई बढ़ गई, और उच्च आवृत्तियों के लिए यह कम हो गया। नए विंडो ट्रांसफ़ॉर्मेशन को स्ट्रेचिंग (कम्प्रेशन) और एक जेनरेटिंग (तथाकथित स्केलिंग फंक्शन - स्केलिंग फंक्शन, स्केलेट) फंक्शन के ऑफ़सेट के परिणामस्वरूप प्राप्त किया गया था। इस जनरेटिंग फ़ंक्शन को डी। मोरलिक्स ने तरंगिका कहा था।

वेवलेट डी। मोरलैक्स

from pylab import* import scaleogram as scg axes = scg.plot_wav('cmor1-1.5', figsize=(14,3)) show()

सतत वेवलेट ट्रांसफ़ॉर्म (CWT)

एकल-स्तरीय तरंगिका परिवर्तन:

coefs, आवृत्तियों = pywt.cwt (डेटा, स्केल, वेवलेट)

जहां:

डेटा: (array_like) -Input संकेत;

तराजू (array_like) : - उपयोग करने के लिए तरंग पैमाने। आप अनुपात f = scale2frequency (स्केल, वेवलेट) / sampling_period का उपयोग कर सकते हैं और निर्धारित कर सकते हैं कि भौतिक आवृत्ति f क्या है। इधर, हर्ट्ज में जब सैम्पलिंग_पेरोड सेकंड में;

तरंगिका (वेवलेट ऑब्जेक्ट या नाम) : - तरंगिका का उपयोग करने के लिए;

sampling_period (फ्लोट): - आउटपुट आवृत्तियों (वैकल्पिक पैरामीटर) के लिए नमूनाकरण अवधि। Coefs के लिए गणना किए गए मान, sampling_period से स्वतंत्र हैं (यानी, अवधि नमूना के लिए स्केल नहीं किए गए हैं;)।

coefs (array_like) : - निरंतर तरंगिका - किसी दिए गए पैमाने और तरंगिका के लिए इनपुट संकेत का परिवर्तन;

आवृत्तियों (array_like) : - यदि नमूने की अवधि की इकाई दूसरी है और सेट की जाती है, तो आवृत्तियों को हर्ट्ज में प्रदर्शित किया जाता है। अन्यथा, 1 का नमूना अवधि मान लिया गया है।

नोट: गुणांक सरणियों का आकार इनपुट सरणी की लंबाई और दिए गए तराजू की लंबाई पर निर्भर करता है।

उपलब्ध cwt संगत तरंगिका नामों की सूची प्राप्त करें:

 >>> import pywt >>> wavlist = pywt.wavelist(kind='continuous') >>> wavlist

['cgau1', 'cgau2', 'cgau3', 'cgau4', 'cgau5', 'cgau6', 'cgau7', 'cgau8', 'cmor', 'fbsp', 'gaus1', 'gaus2', 'gaus2', ' गाऊस 3 ',' गाऊस 4 ',' गाऊस 5 ',' गाऊस 6 ',' गाऊस 7 ',' गाऊस 8 ',' मेक्सिको ',' मॉरल ',' शान ']

तरंग विश्लेषण के लिए, माँ तरंग की पसंद प्रमुख कार्यों में से एक है। इसलिए, प्रत्येक तरंगिका चयन से पहले, निम्नलिखित कार्यक्रम का उपयोग करना आवश्यक है जो आपको तरंगिका के गतिशील गुणों को निर्धारित करने की अनुमति देता है:

लिस्टिंग 1

 import numpy as np import pywt import matplotlib.pyplot as plt vav='cmor1.5-1.0' wav = pywt.ContinuousWavelet(vav) #  ,      print("       [{}, {}]".format( wav.lower_bound, wav.upper_bound)) width = wav.upper_bound - wav.lower_bound scales = [1, 2, 3, 4, 10, 15] max_len = int(np.max(scales)*width + 1) t = np.arange(max_len) fig, axes = plt.subplots(len(scales), 2, figsize=(12, 6)) for n, scale in enumerate(scales): #       cwt int_psi, x = pywt.integrate_wavelet(wav, precision=10) step = x[1] - x[0] j = np.floor( np.arange(scale * width + 1) / (scale * step)) if np.max(j) >= np.size(int_psi): j = np.delete(j, np.where((j >= np.size(int_psi)))[0]) j = j.astype(np.int) # normalize int_psi     int_psi /= np.abs(int_psi).max() #     filt = int_psi[j][::-1] # CWT          #          . nt = len(filt) t = np.linspace(-nt//2, nt//2, nt) axes[n, 0].plot(t, filt.real, t, filt.imag) axes[n, 0].set_xlim([-max_len//2, max_len//2]) axes[n, 0].set_ylim([-1, 1]) axes[n, 0].text(50, 0.35, 'scale = {}'.format(scale)) f = np.linspace(-np.pi, np.pi, max_len) filt_fft = np.fft.fftshift(np.fft.fft(filt, n=max_len)) filt_fft /= np.abs(filt_fft).max() axes[n, 1].plot(f, np.abs(filt_fft)**2) axes[n, 1].set_xlim([-np.pi, np.pi]) axes[n, 1].set_ylim([0, 1]) axes[n, 1].set_xticks([-np.pi, 0, np.pi]) axes[n, 1].set_xticklabels([r'$-\pi$', '0', r'$\pi$']) axes[n, 1].grid(True, axis='x') axes[n, 1].text(np.pi/2, 0.5, 'scale = {}'.format(scale)) axes[n, 0].set_xlabel('time (samples)') axes[n, 1].set_xlabel('frequency (radians)') axes[0, 0].legend(['real', 'imaginary'], loc='upper left') axes[0, 1].legend(['Power'], loc='upper left') axes[0, 0].set_title('filter: wavelet - %s'%vav) axes[0, 1].set_title(r'|FFT(filter)|$^2$') plt.show()

अगला, हम उपरोक्त कार्यक्रम का उपयोग करते हुए तरंग कार्यों और उनके गुणों पर विचार करेंगे:

मैक्सिकन टोपी तरंग मेक्सिको:

\ varphi \ बाएँ (t \ right) = \ frac {2} {\ sqrt {3} \ sqrt [4] {\ pi}} \ cdot exp ^ {- \ frac {t ^ {2}} [2}} } \ cdot \ left (1-t ^ {2} \ right)

$\ varphi \ बाएँ (t \ right) = \ frac {2} {\ sqrt {3} \ sqrt [4] {\ pi}} \ cdot exp ^ {- \ frac {t ^ {2}} [2}} } \ cdot \ left (1-t ^ {2} \ right)$

वेवलेट "मोरल" मोरलिक्स:

v a r p h i l e f t (t r i g h t) = e x p^{- f r a c t^{2} 2} c d o t c o s (5 t)

$\ varphi \ left (t \ right) = exp ^ {- \ frac {t ^ {2}} {2}} \ cdot cos (5t)$

कॉम्प्लेक्स मॉर्लेट वेवलेट "cmorB-C"

v a r p h i ब ा ए ँ (t द ा ए ँ) = f r a c 1 s q r t p i B e x p^{- f r a c t^{2} B}_{c} d o t e x p^{j 2_{i} p i स ी ट ी}

$\ varphi \ बाएँ (t \ दाएँ) = \ frac {1} {\ sqrt {\ pi} B} exp ^ {- \ frac {t ^ {2}} {B}} \ _ cdot exp ^ {j2_i pi सी टी}$

जहां B बैंडविड्थ है; C केंद्र आवृत्ति है।

इसके बाद (विशेष संकेत के बिना) बी, सी के मान एक अस्थायी बिंदु के साथ सेट किए जाते हैं।

गाऊसी तरंगों "गाऊस"

v a r p h i l e f t (t r i g h t) = C c d o t e x p^{- t^{2}}

$\ varphi \ left (t \ right) = C \ cdot exp ^ {- t ^ {2}}$

जहां: पी - 1 से 8 तक के पूर्णांक को तरंगिका के नाम से डाला जाता है, उदाहरण के लिए, "गॉस 8"; C- बिल्ट-इन सामान्यीकरण स्थिरांक।

एकीकृत गाऊसी तरंगें "cgauP"

v a r p h i l e f t (t r i g h t) = C c d o t e x p^{- t^{2}} c d o t e x p^{- j t}

$\ varphi \ left (t \ right) = C \ cdot exp ^ {- t ^ {2}} \ cdot exp ^ {- jt}$

जहाँ: P - 1 से 8 तक का पूर्णांक तरंगिका के नाम से डाला जाता है, उदाहरण के लिए, "gaus8" और वेवलेट फ़ंक्शन के व्युत्पन्न के क्रम के अनुरूप; C- बिल्ट-इन सामान्यीकरण स्थिरांक।

शैनन तरंग "शानब-सी"

v a r p h i ब ा ए ँ (t द ा ए ँ) = s q r t B c d o t f r a c प ा प (p i B t) p i B T c d o t e x p^{j 2 p i C t}

$\ varphi \ बाएँ (t \ दाएँ) = \ sqrt {B} \ cdot \ frac {पाप (\ pi B t)} {\ pi B T} \ cdot exp ^ {j 2 pi C t}$

जहां: बी बैंडविड्थ है; C केंद्र आवृत्ति है।

PyWavelets में सीडब्ल्यूटी डेटा को असतत करने के लिए लागू होता है - तरंग अभिन्न के नमूने के साथ संकल्प। यदि स्केल बहुत छोटा है, तो हमें अपर्याप्त नमूने के साथ एक असतत फ़िल्टर मिलता है, जिससे स्मूथिंग होती है, जैसा कि तरंगिका 'cmor1.5-1.0' के लिए ग्राफ में दिखाया गया है।

बाएं कॉलम में, ग्राफ़ विभिन्न पैमानों के लिए कनवल्शन में इस्तेमाल किए गए असतत फ़िल्टर दिखाते हैं। दायां स्तंभ प्रत्येक फिल्टर का संगत फूरियर पावर स्पेक्ट्रा है। ग्राफ 'cmor1.5-1.0' के लिए तराजू 1 और 2 के साथ, यह देखा जा सकता है कि Nyquist बाधा के उल्लंघन के कारण चौरसाई होती है। संकेतित घटना सी और बी का चयन करते समय अन्य तरंगों में हो सकती है, इसलिए, तरंगिकाओं के साथ काम करते समय, आपको प्रोग्राम का उपयोग करना चाहिए - लिस्टिंग 1।

किसी विशिष्ट सिग्नल आवृत्ति को दिए गए पैमाने से संबंधित करने के लिए, सिग्नल के नमूने की अवधि ज्ञात होनी चाहिए। Pywt.scale2frequency () फ़ंक्शन का उपयोग करके, आप तराजू की सूची को संबंधित आवृत्तियों में परिवर्तित कर सकते हैं। तराजू का सही विकल्प चयनित तरंगिका पर निर्भर करता है, इसलिए pywt.scale2frequency () का उपयोग सिग्नल की संबंधित आवृत्ति सीमा का विचार प्राप्त करने के लिए किया जाना चाहिए।

 >>> import pywt >>> dt = 0.01 # 100 Hz sampling >>> frequencies = pywt.scale2frequency('cmor1.5-1.0', [1, 2, 3, 4]) / dt >>> frequencies

सरणी ([100., 50., 33.33333333, 25.])

वेवलेट - सीडब्ल्यूटी पायवेलेट्स का उपयोग करके टाइम सीरीज़ विश्लेषण

एल-नीनो डेटासेट एक समय श्रृंखला डेटासेट है जिसका उपयोग एल नीनो को ट्रैक करने के लिए किया जाता है और इसमें 1871 से 1997 तक त्रैमासिक समुद्री सतह तापमान माप शामिल हैं। स्केल चार्ट की शक्ति को समझने के लिए, आइए, इसे एल-नीनो डेटासेट के साथ-साथ मूल समय श्रृंखला के डेटा और इसके फूरियर ट्रांसफॉर्म के लिए कल्पना करें।

समय श्रृंखला के तरंगिका विश्लेषण के लिए, निम्नलिखित चरणों का पालन किया जाना चाहिए:

1. माँ तरंगिका का चयन करें: जटिल मोरलेट तरंगिका "cmorB-C" चुनें:

v a r p h i ब ा ए ँ (t द ा ए ँ) = f r a c 1 s q r t p i B e x p^{- f r a c t^{2} B}_{c} d o t e x p^{j 2_{i} p i स ी ट ी}

$\ varphi \ बाएँ (t \ दाएँ) = \ frac {1} {\ sqrt {\ pi} B} exp ^ {- \ frac {t ^ {2}} {B}} \ _ cdot exp ^ {j2_i pi सी टी}$

बैंडविड्थ - बी और केंद्र आवृत्ति - जिससे हम अगले चरण में निर्धारित करेंगे।

2. हमारे समय श्रृंखला के लिए dt = 0.25 लेकर केंद्र की आवृत्ति निर्धारित करें:

 import pywt dt = 0.25 # 4 Hz sampling scale=range(1,4) frequencies = pywt.scale2frequency('cmor1.0-0.5', scale) / dt print(frequencies)

[2। 1. 0.66666667]

3. हम माँ तरंगिका cmor1.0-0.5 के फूरियर रूपांतरण पाते हैं (हम लिस्टिंग 1 का उपयोग करते हैं):
संपूर्ण रेंज में निरंतर तरंगिका का मूल्यांकन किया जाएगा [-8.0, 8.0]

4. समय श्रृंखला के लिए डेटा का चयन करें:

 pd.read_csv("http://paos.colorado.edu/research/wavelets/wave_idl/sst_nino3.dat", sep = "|")

डेटा त्रैमासिक समुद्री सतह के तापमान माप 1871 से 1997 तक हैं। इस डेटा के लिए: t0 = 1871 dt = 0.25

5. हम एक सिग्नल के साथ एक समय श्रृंखला बनाते हैं और एक चार्ट पर इसकी औसत चलती है:

लिस्टिंग 2

 from numpy import * from scipy import * import pandas as pd from pylab import * import pywt def get_ave_values(xvalues, yvalues, n = 5): signal_length = len(xvalues) if signal_length % n == 0: padding_length = 0 else: padding_length = n - signal_length//n % n xarr = array(xvalues) yarr = array(yvalues) xarr.resize(signal_length//n, n) yarr.resize(signal_length//n, n) xarr_reshaped = xarr.reshape((-1,n)) yarr_reshaped = yarr.reshape((-1,n)) x_ave = xarr_reshaped[:,0] y_ave = nanmean(yarr_reshaped, axis=1) return x_ave, y_ave def plot_signal_plus_average(time, signal, average_over = 5): fig, ax = subplots(figsize=(15, 3)) time_ave, signal_ave = get_ave_values(time, signal, average_over) ax.plot(time, signal, label='') ax.plot(time_ave, signal_ave, label = '   (n={})'.format(5)) ax.set_xlim([time[0], time[-1]]) ax.set_ylabel(' ', fontsize=18) ax.set_title(' +   ', fontsize=18) ax.set_xlabel('', fontsize=18) ax.legend() show() df_nino = pd.read_csv("http://paos.colorado.edu/research/wavelets/wave_idl/sst_nino3.dat", sep = "|") N = df_nino.shape[0] t0=1871 dt=0.25 time = arange(0, N) * dt + t0 signal = df_nino.values.squeeze() scales = arange(1, 128) plot_signal_plus_average(time, signal)

6. हम समय श्रृंखला से फूरियर रूपांतरण और स्पेक्ट्रम मोडेलिटी को अंजाम देते हैं:

लिस्टिंग 3

 from numpy import * from scipy import * import pandas as pd from pylab import * import pywt def get_ave_values(xvalues, yvalues, n = 5): signal_length = len(xvalues) if signal_length % n == 0: padding_length = 0 else: padding_length = n - signal_length//n % n xarr = array(xvalues) yarr = array(yvalues) xarr.resize(signal_length//n, n) yarr.resize(signal_length//n, n) xarr_reshaped = xarr.reshape((-1,n)) yarr_reshaped = yarr.reshape((-1,n)) x_ave = xarr_reshaped[:,0] y_ave = nanmean(yarr_reshaped, axis=1) return x_ave, y_ave def get_fft_values(y_values, T, N, f_s): f_values = linspace(0.0, 1.0/(2.0*T), N//2) fft_values_ = fft(y_values) fft_values = 2.0/N * abs(fft_values_[0:N//2]) return f_values, fft_values def plot_fft_plus_power(time, signal): dt = time[1] - time[0] N = len(signal) fs = 1/dt fig, ax = subplots(figsize=(15, 3)) variance = std(signal)**2 f_values, fft_values = get_fft_values(signal, dt, N, fs) fft_power = variance * abs(fft_values) ** 2 # FFT power spectrum ax.plot(f_values, fft_values, 'r-', label='FFT ') ax.plot(f_values, fft_power, 'k--', linewidth=1, label=' ') ax.set_xlabel('[ / ]', fontsize=18) ax.set_ylabel('', fontsize=18) ax.legend() show() df_nino = pd.read_csv("http://paos.colorado.edu/research/wavelets/wave_idl/sst_nino3.dat", sep = "|") N = df_nino.shape[0] t0=1871 dt=0.25 time = arange(0, N) * dt + t0 signal = df_nino.values.squeeze() scales = arange(1, 128) plot_fft_plus_power(time, signal)

7. हम तराजू निर्धारित करते हैं: तराजू = व्यवस्था (1, 128); स्तर = [२ ** - ४, २ ** - ३, २ ** - २, २ ** - १, २ ** ०, २ ** १, २ ** २, २ ** ३]।

8. एक स्केल चार्ट बनाएँ:

लिस्टिंग 4

 from numpy import * import pandas as pd from pylab import * import pywt def plot_wavelet(time, signal, scales, waveletname = 'cmor1.0-0.4', cmap = plt.cm.seismic, title = '-( ) ', ylabel = ' ()', xlabel = ''): dt = time[1] - time[0] [coefficients, frequencies] = pywt.cwt(signal, scales, waveletname, dt) power = (abs(coefficients)) ** 2 period = 1. / frequencies levels = [2**-4 , 2**-3 , 2**-2 , 2**-1 , 2**0 , 2**1 , 2**2 , 2**3] contourlevels = log2(levels) fig, ax = subplots(figsize=(15, 10)) im = ax.contourf(time, log2(period), log2(power), contourlevels, extend='both',cmap=cmap) ax.set_title(title, fontsize=20) ax.set_ylabel(ylabel, fontsize=18) ax.set_xlabel(xlabel, fontsize=18) yticks = 2**arange(np.ceil(log2(period.min())), ceil(log2(period.max()))) ax.set_yticks(log2(yticks)) ax.set_yticklabels(yticks) ax.invert_yaxis() ylim = ax.get_ylim() ax.set_ylim(ylim[0], -1) cbar_ax = fig.add_axes([0.95, 0.5, 0.03, 0.25]) fig.colorbar(im, cax=cbar_ax, orientation="vertical") show() df_nino = pd.read_csv("http://paos.colorado.edu/research/wavelets/wave_idl/sst_nino3.dat", sep = "|") N = df_nino.shape[0] t0=1871 dt=0.25 time = arange(0, N) * dt + t0 signal = df_nino.values.squeeze() scales = arange(1, 128) plot_wavelet(time, signal, scales)

स्केल चार्ट से पता चलता है कि अधिकांश स्पेक्ट्रम शक्ति 2-8 वर्षों की अवधि में केंद्रित है, यह 0.125 - 0.5zz की आवृत्ति से मेल खाती है। फूरियर स्पेक्ट्रम में, फैशन इन आवृत्ति मूल्यों के आसपास भी केंद्रित है। हालाँकि, तरंग परिवर्तन भी हमें अस्थायी जानकारी देता है, लेकिन फूरियर रूपांतरण नहीं करता है।

उदाहरण के लिए, स्केल आरेख पर, हम देखते हैं कि 1920 से पहले कई उतार-चढ़ाव थे, जबकि 1960 और 1990 के बीच इतने सारे नहीं थे। हम यह भी देख सकते हैं कि समय के साथ छोटी से लंबी अवधि के लिए एक बदलाव है।

स्केलोग्राम मॉड्यूल का उपयोग करना

पैवेलवेलेट्स लाइब्रेरी पर आधारित निरंतर तरंगिका परिवर्तन के साथ 1D डेटा का विश्लेषण करने के लिए स्केलोग्राम एक सुविधाजनक उपकरण है। मॉड्यूल को त्वरित डेटा विश्लेषण के लिए एक विश्वसनीय उपकरण प्रदान करने के लिए डिज़ाइन किया गया है।

स्केलोग्राम में निम्नलिखित विशेषताएं हैं:

सरल शुरुआत कॉल हस्ताक्षर
पठनीय कुल्हाड़ियों और शुद्ध matplotlib एकीकरण
जूमिंग, स्पेक्ट्रम फिल्टर, कलरबार कार्यान्वयन, आदि के लिए कई विकल्प ...
अंकन के अनुसार आवृत्ति और आवृत्ति इकाइयों के लिए समर्थन
गति, परिवर्तनों के लिए एन * लॉग (एन) एल्गोरिथ्म का उपयोग करता है
पोर्टेबिलिटी: python2.7 और python3.7 के साथ परीक्षण किया गया
उदाहरणों के साथ विस्तृत त्रुटि संदेश और प्रलेखन

हालाँकि, उपयोग के उदाहरणों में, डेटा एक्सेस सही तरीके से दर्ज नहीं किया गया है:

 nino3 = "http://paos.colorado.edu/research/wavelets/wave_idl/sst_nino3.dat"

निम्नलिखित चेतावनी दिखाई देती है:

nino3 = pd.read_table (nino3)
एक चेतावनी के लिए अग्रणी:
चेतावनी (चेतावनी मॉड्यूल से):
फ़ाइल "C: /User/User/Desktop/wavelet/pr.py", पंक्ति 7
nino3 = pd.read_table (nino3)
FutureWarning: read_table पदावनत है, इसके बजाय read_csv का उपयोग करें, पासिंग sep = 't'

डेटा एक्सेस इस तरह लिखा जाना चाहिए:

 url="http://paos.colorado.edu/research/wavelets/wave_idl/sst_nino3.dat" nino3 = pd.read_csv(url, sep = "|")

स्केलोग्राम का उपयोग दिखाने के लिए और पिछले उदाहरण के परिणामों के साथ परिणामों की तुलना करने के लिए, हम एक ही डेटा का उपयोग करते हैं - 1871 से 1997 तक समुद्र की सतह के तापमान के त्रैमासिक माप पर। इस डेटा के लिए: t0 = 1871 dt = 0.25

लिस्टिंग 4

 import pandas as pd import pywt from numpy import* import scaleogram as scg from pylab import* url="sst_nino3.dat" nino3 = pd.read_csv(url, sep = "|") data = nino3.values.squeeze() N = data.size t0 = 1871; dt = 0.25 time = t0 + arange(len(data))*dt wavelet = 'cmor1-0.5' ax = scg.cws(time, data, scales=arange(1, 128), wavelet=wavelet, figsize=(14, 3), cmap="jet", cbar=None, ylabel=' ()', xlabel=" []", yscale="log", title='-  \n( )') ticks = ax.set_yticks([2,4,8, 16,32]) ticks = ax.set_yticklabels([2,4,8, 16,32]) show()

यदि हम परिणामी स्कैन के साथ स्केल चार्ट की तुलना करते हैं, तो, रंग पैलेट के अपवाद के साथ, वे समान हैं, और इसलिए समय श्रृंखला में समान गतिशीलता दिखाते हैं।
4 की लिस्टिंग 3 की सूची की तुलना में सरल है और इसमें बेहतर प्रदर्शन है।

जब फूरियर के अनुसार आवृत्ति स्पेक्ट्रम और पावर स्पेक्ट्रम समय श्रृंखला की गतिशीलता पर अतिरिक्त जानकारी प्राप्त करने की अनुमति नहीं देते हैं, तो एक स्केलोग्राम का उपयोग बेहतर होता है।

निष्कर्ष

PyWavelets पुस्तकालय के माध्यम से समय श्रृंखला के तरंग विश्लेषण का एक उदाहरण दिया गया है।

तरंग विश्लेषण। भाग २

परिचय

सतत वेवलेट ट्रांसफ़ॉर्म (CWT)

वेवलेट - सीडब्ल्यूटी पायवेलेट्स का उपयोग करके टाइम सीरीज़ विश्लेषण

स्केलोग्राम मॉड्यूल का उपयोग करना

निष्कर्ष

More articles: