मुझे स्थिर रंगीन समय-श्रृंखला का एक सेट उत्पन्न करने में समस्या हो रही है, उनके सहसंयोजक मैट्रिक्स (उनकी पावर वर्णक्रमीय घनत्व (PSDs) और क्रॉस-पावर वर्णक्रमीय घनत्व (CSDs)) को देखते हुए।
मुझे पता है कि, दो टाइम-सीरीज़ और , मैं उनकी पावर वर्णक्रमीय घनत्व (PSDs) का अनुमान लगा सकता हूं और कई व्यापक रूटीनों का उपयोग करके क्रॉस स्पेक्ट्रल घनत्व (CSDs) कर सकता हूं, जैसे कि और Matlab, आदि में कार्य और PSDs और CSD सहसंयोजक मैट्रिक्स बनाते हैं:
psd()csd()
अगर मैं रिवर्स करना चाहता हूं तो क्या होगा? सहसंयोजक मैट्रिक्स को देखते हुए, मैं और एहसास कैसे उत्पन्न ?
कृपया कोई भी पृष्ठभूमि सिद्धांत शामिल करें, या ऐसा करने वाले किसी भी मौजूदा टूल को इंगित करें (पायथन में कुछ भी महान होगा)।
मेरा प्रयास
नीचे मैंने जो कोशिश की है, और मैंने जिन समस्याओं पर ध्यान दिया है, उनका वर्णन है। यह थोड़ा लंबा पढ़ा गया है, और यदि इसमें ऐसे शब्द शामिल हैं, जिनका दुरुपयोग हुआ है, तो क्षमा करें। यदि जो गलत है, उसे इंगित किया जा सकता है, तो यह बहुत मददगार होगा। लेकिन मेरा सवाल ऊपर बोल्ड में एक है।
- PSDs और CSD को टाइम-सीरीज़ के फूरियर ट्रांसफॉर्म के उत्पादों के अपेक्षा मूल्य (या पहनावा औसत) के रूप में लिखा जा सकता है। तो, सहसंयोजक मैट्रिक्स के रूप में लिखा जा सकता है:
जहां
- एक सहसंयोजक मैट्रिक्स एक हर्मिटियन मैट्रिक्स है, जिसमें वास्तविक ईजेंवल्यूल्स होते हैं जो या तो शून्य या सकारात्मक होते हैं। तो, इसे में विघटित किया जा सकता है। : \ boldsymbol \ lambda ^ {\ frac {1} {2}} (f) \ mathbf {X} ^ {\ dagger} (f) \;; जहां एक विकर्ण मैट्रिक्स है, जिसके गैर-शून्य तत्व के eigenvalues के वर्ग-मूल हैं; वह मैट्रिक्स है जिसके कॉलम ; पहचान मैट्रिक्स है।
- पहचान मैट्रिक्स को रूप में लिखा जाता है
जहां
और शून्य माध्य और इकाई विचरण के साथ असंबंधित और जटिल आवृत्ति-श्रृंखला है।
- 3. में 3 का उपयोग करके। और फिर 1 के साथ तुलना करें। टाइम-सीरीज़ के फूरियर रूपांतरण हैं:
- समय-श्रृंखला को व्युत्क्रम तेजी से फूरियर रूपांतरण की तरह दिनचर्या का उपयोग करके प्राप्त किया जा सकता है।
मैंने इसे करने के लिए पायथन में एक दिनचर्या लिखी है:
def get_noise_freq_domain_CovarMatrix( comatrix , df , inittime , parityN , seed='none' , N_previous_draws=0 ) :
"""
returns the noise time-series given their covariance matrix
INPUT:
comatrix --- covariance matrix, Nts x Nts x Nf numpy array
( Nts = number of time-series. Nf number of positive and non-Nyquist frequencies )
df --- frequency resolution
inittime --- initial time of the noise time-series
parityN --- is the length of the time-series 'Odd' or 'Even'
seed --- seed for the random number generator
N_previous_draws --- number of random number draws to discard first
OUPUT:
t --- time [s]
n --- noise time-series, Nts x N numpy array
"""
if len( comatrix.shape ) != 3 :
raise InputError , 'Input Covariance matrices must be a 3-D numpy array!'
if comatrix.shape[0] != comatrix.shape[1] :
raise InputError , 'Covariance matrix must be square at each frequency!'
Nts , Nf = comatrix.shape[0] , comatrix.shape[2]
if parityN == 'Odd' :
N = 2 * Nf + 1
elif parityN == 'Even' :
N = 2 * ( Nf + 1 )
else :
raise InputError , "parityN must be either 'Odd' or 'Even'!"
stime = 1 / ( N*df )
t = inittime + stime * np.arange( N )
if seed == 'none' :
print 'Not setting the seed for np.random.standard_normal()'
pass
elif seed == 'random' :
np.random.seed( None )
else :
np.random.seed( int( seed ) )
print N_previous_draws
np.random.standard_normal( N_previous_draws ) ;
zs = np.array( [ ( np.random.standard_normal((Nf,)) + 1j * np.random.standard_normal((Nf,)) ) / np.sqrt(2)
for i in range( Nts ) ] )
ntilde_p = np.zeros( ( Nts , Nf ) , dtype=complex )
for k in range( Nf ) :
C = comatrix[ :,:,k ]
if not np.allclose( C , np.conj( np.transpose( C ) ) ) :
print "Covariance matrix NOT Hermitian! Unphysical."
w , V = sp_linalg.eigh( C )
for m in range( w.shape[0] ) :
w[m] = np.real( w[m] )
if np.abs(w[m]) / np.max(w) < 1e-10 :
w[m] = 0
if w[m] < 0 :
print 'Negative eigenvalue! Simulating unpysical signal...'
ntilde_p[ :,k ] = np.conj( np.sqrt( N / (2*stime) ) * np.dot( V , np.dot( np.sqrt( np.diag( w ) ) , zs[ :,k ] ) ) )
zerofill = np.zeros( ( Nts , 1 ) )
if N % 2 == 0 :
ntilde = np.concatenate( ( zerofill , ntilde_p , zerofill , np.conj(np.fliplr(ntilde_p)) ) , axis = 1 )
else :
ntilde = np.concatenate( ( zerofill , ntilde_p , np.conj(np.fliplr(ntilde_p)) ) , axis = 1 )
n = np.real( sp.ifft( ntilde , axis = 1 ) )
return t , n
मैंने इस दिनचर्या को PSDs और CSDs में लागू किया है, जिसके विश्लेषणात्मक भाव कुछ डिटेक्टरों के मॉडलिंग से प्राप्त किए गए हैं जिनके साथ मैं काम कर रहा हूं। महत्वपूर्ण बात यह है कि सभी आवृत्तियों पर, वे एक सहसंयोजक मैट्रिक्स बनाते हैं (अच्छी तरह से कम से कम वे उन सभी ifबयानों को दिनचर्या में पास करते हैं)। सहसंयोजक मैट्रिक्स 3x3 है। 3 समय-श्रृंखला लगभग 9000 बार उत्पन्न हुई है, और अनुमानित PSDs और CSDs, इन सभी अहसासों को औसतन विश्लेषणात्मक लोगों के साथ नीचे प्लॉट किए गए हैं। जबकि समग्र आकार सहमत हैं, CSDs (Fig.2) में कुछ आवृत्तियों पर ध्यान देने योग्य शोर विशेषताएं हैं । PSDs (Fig.3) में चोटियों के आसपास एक क्लोज-अप के बाद, मैंने देखा कि PSDs वास्तव में कम करके आंका गया है, और यह कि सीएसडी में शोर की विशेषताएं PSDs में चोटियों के समान होती हैं। मुझे नहीं लगता कि यह एक संयोग है, और यह कि किसी भी तरह PSDs से CSD में बिजली लीक हो रही है। मुझे उम्मीद है कि डेटा के इस अहसास के साथ घटता एक दूसरे के ऊपर झूठ बोल सकता है।
