การจำลองอนุกรมเวลาที่ให้กำลังและความหนาแน่นสเปกตรัมข้าม

ฉันมีปัญหาในการสร้างชุดของชุดสีเวลาคงที่ให้เมทริกซ์ความแปรปรวนร่วมของพวกเขา (ความหนาแน่นสเปกตรัมพลังงานของพวกเขา (PSDs) และความหนาแน่นสเปกตรัมข้ามอำนาจ (CSDs)

ฉันรู้ว่าเมื่อได้รับอนุกรมเวลาสองชุดและฉันสามารถประเมินความหนาแน่นเชิงสเปกตรัมกำลัง (PSDs) และความหนาแน่นข้ามสเปกตรัม (CSDs) โดยใช้กิจวัตรที่มีอยู่มากมายเช่นและฟังก์ชั่นใน Matlab เป็นต้น PSDs และ CSD ประกอบขึ้นเป็นเมทริกซ์ความแปรปรวนร่วม: $y_{I}(t)$$y_{J}(t)$psd()csd()

$$\mathbf{C}(f) = \left( \begin{array}{cc} P_{II}(f) & P_{IJ}(f)\\ P_{JI}(f) & P_{JJ}(f) \end{array} \right)\;,$$ ซึ่งอยู่ในฟังก์ชั่นทั่วไปของความถี่ฉ $f$

จะเกิดอะไรขึ้นถ้าฉันต้องการย้อนกลับ รับเมทริกซ์ความแปรปรวนร่วมฉันจะสร้างการรับรู้ของและอย่างไร$y_{I}(t)$$y_{J}(t)$

โปรดรวมทฤษฎีพื้นหลังใด ๆ หรือชี้ให้เห็นเครื่องมือที่มีอยู่ใด ๆ ที่ทำสิ่งนี้ (สิ่งใดใน Python จะดีมาก)

ความพยายามของฉัน

ด้านล่างนี้เป็นคำอธิบายของสิ่งที่ฉันได้ลองและปัญหาที่ฉันสังเกตเห็น มันเป็นบิตของการอ่านนานและขอโทษถ้ามันมีคำศัพท์ที่ใช้ในทางที่ผิด หากสิ่งที่ผิดพลาดสามารถชี้ให้เห็นว่าจะเป็นประโยชน์มาก แต่คำถามของฉันคือตัวหนาด้านบน

1. PSDs และ CSDs สามารถเขียนเป็นค่าความคาดหวัง (หรือค่าเฉลี่ยทั้งหมด) ของผลิตภัณฑ์ของการแปลงฟูริเยร์ของอนุกรมเวลา ดังนั้นเมทริกซ์ความแปรปรวนร่วมสามารถเขียนเป็น: ที่ไหน $$\mathbf{C}(f) = \frac{2}{\tau} \langle \mathbf{Y}^{\dagger}(f) \mathbf{Y}(f) \rangle \;,$$ $$\mathbf{Y}(f) = \left( \begin{array}{cc} \tilde{y}_{I}(f) & \tilde{y}_{J}(f) \end{array} \right) \;.$$
2. เมทริกซ์ความแปรปรวนร่วมเป็นเมทริกซ์เฮอร์มีเชียนมีค่าลักษณะเฉพาะจริงที่เป็นศูนย์หรือบวก ดังนั้นมันสามารถจำแนกออกเป็น โดยที่เป็นเมทริกซ์แนวทแยงมุมซึ่งองค์ประกอบที่ไม่ใช่ศูนย์คือสแควร์รูทของค่าลักษณะเฉพาะ เป็นเมทริกซ์ที่มีคอลัมน์เป็น eigenvectors orthonormal ของ ; $$\mathbf{C}(f) = \mathbf{X}(f) \boldsymbol\lambda^{\frac{1}{2}}(f) \: \mathbf{I} \: \boldsymbol\lambda^{\frac{1}{2}}(f) \mathbf{X}^{\dagger}(f) \;,$$ $\lambda^{\frac{1}{2}}(f)$$\mathbf{C}(f)$$\mathbf{X}(f)$$\mathbf{C}(f)$$\mathbf{I}$เป็นเมทริกซ์เอกลักษณ์
3. เมทริกซ์เอกลักษณ์ถูกเขียนเป็น โดยที่ และไม่มีการเชื่อมโยงและชุดความถี่ที่ซับซ้อนซึ่งมีค่าเฉลี่ยศูนย์และค่าความแปรปรวนของหน่วย $$\mathbf{I} = \langle \mathbf{z}^{\dagger}(f) \mathbf{z}(f) \rangle \;,$$ $$\mathbf{z}(f) = \left( \begin{array}{cc} z_{I}(f) & z_{J}(f) \end{array} \right) \;,$$ $\{z_{i}(f)\}_{i=I,J}$
4. โดยใช้ 3. ใน 2 แล้วเปรียบเทียบกับ 1 การแปลงฟูริเยร์ของอนุกรมเวลาคือ: $$\mathbf{Y}(f) = \sqrt{ \frac{\tau}{2} } \mathbf{z}(f) \: \boldsymbol\lambda^{\frac{1}{2}}(f) \: \mathbf{X}^{\dagger}(f) \;.$$
5. จากนั้นอนุกรมเวลาสามารถรับได้โดยใช้รูทีนเช่นการแปลงฟูริเยร์ที่ตรงกันข้าม

ฉันได้เขียนกิจวัตรใน Python เพื่อทำสิ่งนี้:

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

ฉันได้ประยุกต์ใช้รูทีนนี้กับ PSD และ CSDs ซึ่งเป็นนิพจน์การวิเคราะห์ที่ได้รับจากการสร้างแบบจำลองของตัวตรวจจับบางตัวที่ฉันทำงานด้วย สิ่งสำคัญคือที่ความถี่ทั้งหมดพวกเขาทำเมทริกซ์ความแปรปรวนร่วม (อย่างน้อยพวกเขาก็ผ่านข้อความเหล่านั้นทั้งหมดifในรูทีน) เมทริกซ์ความแปรปรวนร่วมเป็น 3x3 ซีรีย์ 3 เวลาถูกสร้างขึ้นประมาณ 9000 ครั้งและ PSDs และ CSDs โดยประมาณซึ่งมีค่าเฉลี่ยสำหรับการรับรู้ทั้งหมดเหล่านี้จะถูกพล็อตด้านล่างด้วยการวิเคราะห์ ในขณะที่รูปร่างโดยรวมเห็นด้วยมีคุณสมบัติที่มีเสียงดังที่เห็นได้ชัดเจนที่ความถี่บางอย่างใน CSD (รูปที่ 2) หลังจากใกล้จุดสูงสุดใน PSD (รูปที่ 3) ฉันสังเกตเห็นว่า PSD นั้นประเมินค่าต่ำไปจริง ๆและคุณสมบัติที่มีเสียงดังใน CSD นั้นเกิดขึ้นที่ความถี่เดียวกับพีคส์ใน PSD ฉันไม่คิดว่านี่เป็นเรื่องบังเอิญและพลังนั้นรั่วไหลจาก PSD เข้าสู่ CSD ฉันคาดหวังว่าเส้นโค้งจะวางซ้อนทับกันด้วยการรับรู้ข้อมูลจำนวนมาก

เนื่องจากสัญญาณของคุณอยู่กับที่วิธีการง่าย ๆ คือการใช้สัญญาณรบกวนสีขาวเป็นพื้นฐานและกรองสัญญาณให้เหมาะกับ PSD ของคุณ วิธีการคำนวณค่าสัมประสิทธิ์กรองเหล่านี้คือการใช้การทำนายเชิงเส้น

ดูเหมือนว่าจะมีฟังก์ชั่นของหลามลองใช้งานดู:

from scikits.talkbox import lpc

หากคุณต้องการ (ฉันเพิ่งใช้ MATLAB ที่เทียบเท่ากัน) นี่เป็นวิธีที่ใช้ในการประมวลผลคำพูดโดยที่ formants ถูกประเมินด้วยวิธีนี้

สายไปงานเลี้ยงตามปกติ แต่ฉันเห็นกิจกรรมล่าสุดบางอย่างดังนั้นฉันจะสองเยนของฉัน

ครั้งแรกฉันไม่สามารถติติง OPs ได้ - มันดูเหมาะสมสำหรับฉัน ความแตกต่างอาจเกิดจากปัญหาเกี่ยวกับตัวอย่างที่มีขอบเขต จำกัด ตัวอย่างเช่นอคติเชิงบวกของการประมาณกำลังงานสัญญาณ

อย่างไรก็ตามฉันคิดว่ามีวิธีที่ง่ายกว่าในการสร้างอนุกรมเวลาจากเมทริกซ์ความหนาแน่นข้ามสเปกตรัม (CPSD นี่คือสิ่งที่ OP เรียกว่าเมทริกซ์ความแปรปรวนร่วม)

วิธีการหนึ่งในพารามิเตอร์คือการใช้ CPSD เพื่อรับรายละเอียดการตอบกลับอัตโนมัติจากนั้นใช้วิธีนั้นเพื่อสร้างอนุกรมเวลา ใน matlab คุณสามารถทำได้โดยใช้เครื่องมือ Causality Granger (เช่นMultivaraite Granger toolbox, Seth, Barnett ) กล่องเครื่องมือใช้งานง่ายมาก เนื่องจากการมีอยู่ของ CPSD รับประกันคำอธิบายแบบอัตโนมัติขั้นสูงวิธีนี้จึงแน่นอน (สำหรับข้อมูลเพิ่มเติมเกี่ยวกับ CPSD และการตอบโต้อัตโนมัติดู "การวัดการพึ่งพาเชิงเส้นและความคิดเห็นระหว่างอนุกรมเวลาหลายชุด" โดย Geweke, 1982 หรือเอกสาร Aneil Seth + Lionel Barnett หลายแห่งเพื่อให้ได้ภาพเต็ม)

ที่อาจเป็นไปได้ง่ายขึ้นคือการสังเกต CPSD สามารถเกิดขึ้นได้โดยการใช้ fft กับความแปรปรวนร่วมอัตโนมัติ ดังนั้นด้วยการใช้ค่า FFT ผกผันกับ CPSD เราจะได้ค่าความแปรปรวนร่วมและความแปรปรวนร่วมอัตโนมัติ จากนั้นเราสามารถใช้สิ่งเหล่านี้เพื่อสร้างตัวอย่างข้อมูลของเรา

หวังว่านี่จะช่วยได้ กรุณาฝากคำขอใด ๆ สำหรับข้อมูลในความคิดเห็นและฉันจะพยายามที่จะอยู่