ฉันจะใช้ numpy.correlate เพื่อทำ autocorrelation ได้อย่างไร

Question 1

ฉันต้องสร้างความสัมพันธ์อัตโนมัติของชุดตัวเลขซึ่งตามที่ฉันเข้าใจมันเป็นเพียงความสัมพันธ์ของเซตกับตัวมันเอง

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

ดังนั้นคำถามนี้เป็นคำถามสองข้อ:

กำลังnumpy.correlateทำอะไรกันแน่?
ฉันจะใช้มัน (หรืออย่างอื่น) เพื่อสร้างความสัมพันธ์อัตโนมัติได้อย่างไร

Question 2

ในการตอบคำถามแรกของคุณnumpy.correlate(a, v, mode)กำลังดำเนินการ Convolution aด้วยการย้อนกลับvและให้ผลลัพธ์ถูกตัดโดยโหมดที่ระบุ ความหมายของการบิด , C (t) = Σ _{-∞ <i <∞}_ฉันวี_{ที + i}ที่-∞ <T <∞ช่วยให้ผลที่ได้จากการ-∞∞ แต่คุณเห็นได้ชัดไม่สามารถเก็บอนันต์ยาว อาร์เรย์ ดังนั้นจึงต้องมีการตัดและนั่นคือที่มาของโหมดมี 3 โหมดที่แตกต่างกัน: เต็มเหมือนกันและถูกต้อง:

โหมด "เต็ม" จะแสดงผลลัพธ์สำหรับทุกๆtที่aและvมีการทับซ้อนกัน
โหมด "same" จะแสดงผลลัพธ์ที่มีความยาวเท่ากับเวกเตอร์ที่สั้นที่สุด ( aหรือv)
"ถูกต้อง" โหมดผลตอบแทนเฉพาะเมื่อaและvสมบูรณ์ทับซ้อนกัน เอกสารสำหรับการnumpy.convolveให้รายละเอียดเพิ่มเติมเกี่ยวกับโหมด

สำหรับคำถามที่สองของคุณฉันคิดว่าnumpy.correlate กำลังให้ความสัมพันธ์อัตโนมัติกับคุณมันก็แค่ให้คุณมากขึ้นเช่นกัน autocorrelation ใช้เพื่อค้นหาว่าสัญญาณหรือฟังก์ชันที่คล้ายคลึงกันนั้นมีความแตกต่างกันอย่างไรในช่วงเวลาหนึ่ง ที่ความแตกต่างของเวลาเป็น 0 ความสัมพันธ์อัตโนมัติควรสูงที่สุดเนื่องจากสัญญาณเหมือนกันดังนั้นคุณคาดว่าองค์ประกอบแรกในอาร์เรย์ผลลัพธ์ความสัมพันธ์อัตโนมัติจะยิ่งใหญ่ที่สุด อย่างไรก็ตามความสัมพันธ์ไม่ได้เริ่มต้นที่ความแตกต่างของเวลาเป็น 0 มันเริ่มต้นที่ความแตกต่างของเวลาที่เป็นลบปิดที่ 0 แล้วไปเป็นบวก นั่นคือคุณคาดหวังว่า:

autocorrelation (a) = ∑ _{-∞ <i <∞} a _i v _{t + i}โดยที่ 0 <= t <∞

แต่สิ่งที่คุณได้คือ:

autocorrelation (a) = ∑ _{-∞ <i <∞} a _i v _{t + i}โดยที่-∞ <t <∞

สิ่งที่คุณต้องทำคือใช้ครึ่งสุดท้ายของผลลัพธ์สหสัมพันธ์ของคุณและนั่นควรเป็นความสัมพันธ์อัตโนมัติที่คุณกำลังมองหา ฟังก์ชัน python ง่ายๆที่จะทำคือ:

def autocorr(x):
    result = numpy.correlate(x, x, mode='full')
    return result[result.size/2:]

แน่นอนคุณจะต้องตรวจสอบข้อผิดพลาดเพื่อให้แน่ใจว่าxเป็นอาร์เรย์ 1-d นอกจากนี้คำอธิบายนี้อาจไม่ตรงตามหลักคณิตศาสตร์อย่างเคร่งครัด ฉันทุ่มไปกับ infinities เพราะคำจำกัดความของ Convolution ใช้พวกเขา แต่นั่นไม่จำเป็นต้องใช้กับ autocorrelation ดังนั้นส่วนทางทฤษฎีของคำอธิบายนี้อาจจะวอกแวกเล็กน้อย แต่หวังว่าผลในทางปฏิบัติจะเป็นประโยชน์ หน้า เหล่านี้ เกี่ยวกับความสัมพันธ์อัตโนมัติมีประโยชน์มากและสามารถให้พื้นหลังทางทฤษฎีที่ดีขึ้นมากหากคุณไม่คิดที่จะลุยผ่านสัญกรณ์และแนวคิดที่หนักหน่วง

Question 3

ความสัมพันธ์อัตโนมัติมีสองเวอร์ชัน: สถิติและ Convolution ทั้งคู่ทำเหมือนกันยกเว้นรายละเอียดเล็กน้อย: เวอร์ชันทางสถิติจะถูกทำให้เป็นมาตรฐานในช่วงเวลา [-1,1] นี่คือตัวอย่างของวิธีการทำสถิติ:

def acf(x, length=20):
    return numpy.array([1]+[numpy.corrcoef(x[:-i], x[i:])[0,1]  \
        for i in range(1, length)])

Question 4

ใช้numpy.corrcoefฟังก์ชันแทนnumpy.correlateการคำนวณความสัมพันธ์ทางสถิติสำหรับความล่าช้าของ t:

def autocorr(x, t=1):
    return numpy.corrcoef(numpy.array([x[:-t], x[t:]]))

Question 5

ฉันคิดว่ามี 2 สิ่งที่ทำให้หัวข้อนี้สับสน:

นิยามเชิงสถิติเทียบกับการประมวลผลสัญญาณ: ตามที่คนอื่น ๆ ชี้ให้เห็นในสถิติเราปรับความสัมพันธ์อัตโนมัติให้เป็น [-1,1]
ค่าเฉลี่ย / ความแปรปรวนบางส่วนและไม่เป็นบางส่วน: เมื่ออนุกรมเวลาเลื่อนที่ความล่าช้า> 0 ขนาดที่ทับซ้อนกันจะ <ความยาวเดิมเสมอ เราใช้ค่าเฉลี่ยและมาตรฐานของค่าเฉลี่ยดั้งเดิม (ไม่ใช่บางส่วน) หรือคำนวณค่าเฉลี่ยและมาตรฐานใหม่เสมอโดยใช้การทับซ้อนที่เปลี่ยนแปลงตลอดเวลา (บางส่วน) ทำให้เกิดความแตกต่าง (อาจมีคำที่เป็นทางการสำหรับคำนี้ แต่ตอนนี้ฉันจะใช้ "บางส่วน")

ฉันได้สร้างฟังก์ชัน 5 ฟังก์ชันที่คำนวณความสัมพันธ์อัตโนมัติของอาร์เรย์ 1d โดยมีความแตกต่างบางส่วนและไม่ใช่บางส่วน บางคนใช้สูตรจากสถิติบางอย่างใช้ความสัมพันธ์ในแง่การประมวลผลสัญญาณซึ่งสามารถทำได้ผ่าน FFT แต่ผลลัพธ์ทั้งหมดเป็นความสัมพันธ์โดยอัตโนมัติในคำจำกัดความของสถิติดังนั้นจึงแสดงให้เห็นว่ามีการเชื่อมโยงถึงกันอย่างไร รหัสด้านล่าง:

import numpy
import matplotlib.pyplot as plt

def autocorr1(x,lags):
    '''numpy.corrcoef, partial'''

    corr=[1. if l==0 else numpy.corrcoef(x[l:],x[:-l])[0][1] for l in lags]
    return numpy.array(corr)

def autocorr2(x,lags):
    '''manualy compute, non partial'''

    mean=numpy.mean(x)
    var=numpy.var(x)
    xp=x-mean
    corr=[1. if l==0 else numpy.sum(xp[l:]*xp[:-l])/len(x)/var for l in lags]

    return numpy.array(corr)

def autocorr3(x,lags):
    '''fft, pad 0s, non partial'''

    n=len(x)
    # pad 0s to 2n-1
    ext_size=2*n-1
    # nearest power of 2
    fsize=2**numpy.ceil(numpy.log2(ext_size)).astype('int')

    xp=x-numpy.mean(x)
    var=numpy.var(x)

    # do fft and ifft
    cf=numpy.fft.fft(xp,fsize)
    sf=cf.conjugate()*cf
    corr=numpy.fft.ifft(sf).real
    corr=corr/var/n

    return corr[:len(lags)]

def autocorr4(x,lags):
    '''fft, don't pad 0s, non partial'''
    mean=x.mean()
    var=numpy.var(x)
    xp=x-mean

    cf=numpy.fft.fft(xp)
    sf=cf.conjugate()*cf
    corr=numpy.fft.ifft(sf).real/var/len(x)

    return corr[:len(lags)]

def autocorr5(x,lags):
    '''numpy.correlate, non partial'''
    mean=x.mean()
    var=numpy.var(x)
    xp=x-mean
    corr=numpy.correlate(xp,xp,'full')[len(x)-1:]/var/len(x)

    return corr[:len(lags)]


if __name__=='__main__':

    y=[28,28,26,19,16,24,26,24,24,29,29,27,31,26,38,23,13,14,28,19,19,\
            17,22,2,4,5,7,8,14,14,23]
    y=numpy.array(y).astype('float')

    lags=range(15)
    fig,ax=plt.subplots()

    for funcii, labelii in zip([autocorr1, autocorr2, autocorr3, autocorr4,
        autocorr5], ['np.corrcoef, partial', 'manual, non-partial',
            'fft, pad 0s, non-partial', 'fft, no padding, non-partial',
            'np.correlate, non-partial']):

        cii=funcii(y,lags)
        print(labelii)
        print(cii)
        ax.plot(lags,cii,label=labelii)

    ax.set_xlabel('lag')
    ax.set_ylabel('correlation coefficient')
    ax.legend()
    plt.show()

นี่คือรูปผลลัพธ์:

เราไม่เห็นทั้ง 5 เส้นเพราะ 3 เส้นซ้อนกัน (ที่สีม่วง) การทับซ้อนเป็นความสัมพันธ์อัตโนมัติที่ไม่ใช่บางส่วน เนื่องจากการคำนวณจากวิธีการประมวลผลสัญญาณ ( np.correlate, FFT) ไม่คำนวณค่าเฉลี่ย / มาตรฐานที่แตกต่างกันสำหรับการทับซ้อนกัน

โปรดทราบว่าไฟล์ fft, no padding, non-partialผลลัพธ์ (เส้นสีแดง) แตกต่างกันเนื่องจากไม่ได้เติมไทม์ซีรีย์ด้วย 0 ก่อนทำ FFT ดังนั้นจึงเป็น FFT แบบวงกลม ฉันไม่สามารถอธิบายรายละเอียดได้ว่าทำไมนั่นคือสิ่งที่ฉันเรียนรู้จากที่อื่น

Question 6

ในขณะที่ฉันพบปัญหาเดียวกันฉันต้องการแบ่งปันรหัสสองสามบรรทัดกับคุณ ในความเป็นจริงมีหลายโพสต์ที่ค่อนข้างคล้ายกันเกี่ยวกับ autocorrelation ใน stackoverflow ในตอนนี้ หากคุณกำหนดความสัมพันธ์อัตโนมัติเป็นa(x, L) = sum(k=0,N-L-1)((xk-xbar)*(x(k+L)-xbar))/sum(k=0,N-1)((xk-xbar)**2)[นี่คือคำจำกัดความที่กำหนดในฟังก์ชัน a_correlate ของ IDL และสอดคล้องกับสิ่งที่ฉันเห็นในคำตอบที่ 2 ของคำถาม# 12269834 ] สิ่งต่อไปนี้ดูเหมือนจะให้ผลลัพธ์ที่ถูกต้อง:

import numpy as np
import matplotlib.pyplot as plt

# generate some data
x = np.arange(0.,6.12,0.01)
y = np.sin(x)
# y = np.random.uniform(size=300)
yunbiased = y-np.mean(y)
ynorm = np.sum(yunbiased**2)
acor = np.correlate(yunbiased, yunbiased, "same")/ynorm
# use only second half
acor = acor[len(acor)/2:]

plt.plot(acor)
plt.show()

อย่างที่คุณเห็นฉันได้ทดสอบสิ่งนี้ด้วยเส้นโค้งบาปและการแจกแจงแบบสุ่มที่สม่ำเสมอและผลลัพธ์ทั้งสองดูเหมือนว่าฉันคาดหวังไว้ โปรดทราบว่าฉันใช้mode="same"แทนmode="full"อย่างที่คนอื่นทำ

Question 7

คำถาม 1 ของคุณได้รับการกล่าวถึงอย่างกว้างขวางในคำตอบที่ยอดเยี่ยมหลายประการ

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

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

รหัสในการดำเนินการมีดังต่อไปนี้:

def autocorrelation (x) :
    """
    Compute the autocorrelation of the signal, based on the properties of the
    power spectral density of the signal.
    """
    xp = x-np.mean(x)
    f = np.fft.fft(xp)
    p = np.array([np.real(v)**2+np.imag(v)**2 for v in f])
    pi = np.fft.ifft(p)
    return np.real(pi)[:x.size/2]/np.sum(xp**2)

Question 8

ฉันเป็นนักชีววิทยาด้านการคำนวณและเมื่อฉันต้องคำนวณความสัมพันธ์อัตโนมัติ / ข้ามความสัมพันธ์ระหว่างอนุกรมเวลาของกระบวนการสุ่มฉันก็ตระหนักnp.correlateว่าไม่ได้ทำงานที่ฉันต้องการ

อันที่จริงสิ่งที่ดูเหมือนจะขาดหายไปnp.correlateคือค่าเฉลี่ยของจุดเวลาที่เป็นไปได้ทั้งหมดที่ระยะทาง 𝜏

นี่คือวิธีที่ฉันกำหนดฟังก์ชันที่ทำในสิ่งที่ฉันต้องการ:

def autocross(x, y):
    c = np.correlate(x, y, "same")
    v = [c[i]/( len(x)-abs( i - (len(x)/2)  ) ) for i in range(len(c))]
    return v

สำหรับฉันแล้วดูเหมือนว่าไม่มีคำตอบใดก่อนหน้านี้ที่ครอบคลุมกรณีของความสัมพันธ์อัตโนมัติ / ข้ามความสัมพันธ์: หวังว่าคำตอบนี้อาจเป็นประโยชน์สำหรับคนที่ทำงานเกี่ยวกับกระบวนการสุ่มเช่นฉัน

Question 9

ฉันใช้ talib.CORREL สำหรับ autocorrelation เช่นนี้ฉันสงสัยว่าคุณสามารถทำเช่นเดียวกันกับแพ็คเกจอื่น ๆ ได้:

def autocorrelate(x, period):

    # x is a deep indicator array 
    # period of sample and slices of comparison

    # oldest data (period of input array) may be nan; remove it
    x = x[-np.count_nonzero(~np.isnan(x)):]
    # subtract mean to normalize indicator
    x -= np.mean(x)
    # isolate the recent sample to be autocorrelated
    sample = x[-period:]
    # create slices of indicator data
    correls = []
    for n in range((len(x)-1), period, -1):
        alpha = period + n
        slices = (x[-alpha:])[:period]
        # compare each slice to the recent sample
        correls.append(ta.CORREL(slices, sample, period)[-1])
    # fill in zeros for sample overlap period of recent correlations    
    for n in range(period,0,-1):
        correls.append(0)
    # oldest data (autocorrelation period) will be nan; remove it
    correls = np.array(correls[-np.count_nonzero(~np.isnan(correls)):])      

    return correls

# CORRELATION OF BEST FIT
# the highest value correlation    
max_value = np.max(correls)
# index of the best correlation
max_index = np.argmax(correls)

Question 10

การใช้การแปลงฟูเรียร์และทฤษฎีบทการแปลง

ความซับซ้อนของเวลาคือ N * log (N)

def autocorr1(x):
    r2=np.fft.ifft(np.abs(np.fft.fft(x))**2).real
    return r2[:len(x)//2]

นี่คือเวอร์ชันที่ทำให้เป็นมาตรฐานและเป็นกลางนอกจากนี้ยังเป็น N * log (N)

def autocorr2(x):
    r2=np.fft.ifft(np.abs(np.fft.fft(x))**2).real
    c=(r2/x.shape-np.mean(x)**2)/np.std(x)**2
    return c[:len(x)//2]

วิธีการที่ A. Levy ให้ไว้ใช้งานได้ แต่ฉันทดสอบในพีซีของฉันความซับซ้อนของเวลาดูเหมือนจะเป็นN * N

def autocorr(x):
    result = numpy.correlate(x, x, mode='full')
    return result[result.size/2:]

Question 11

ทางเลือกในการ numpy.correlate มีอยู่ในstatsmodels.tsa.stattools.acf () สิ่งนี้ทำให้ฟังก์ชัน autocorrelation ลดลงอย่างต่อเนื่องเหมือนกับที่ OP อธิบายไว้ การนำไปใช้นั้นค่อนข้างง่าย:

from statsmodels.tsa import stattools
# x = 1-D array
# Yield normalized autocorrelation function of number lags
autocorr = stattools.acf( x )

# Get autocorrelation coefficient at lag = 1
autocorr_coeff = autocorr[1]

พฤติกรรมเริ่มต้นคือหยุดที่ 40 nlags แต่สามารถปรับเปลี่ยนได้ด้วยnlag=ตัวเลือกสำหรับแอปพลิเคชันเฉพาะของคุณ มีการอ้างอิงที่ด้านล่างของหน้าสำหรับเป็นสถิติที่อยู่เบื้องหลังการทำงาน

Question 12

ฉันคิดว่าคำตอบที่แท้จริงสำหรับคำถามของ OP นั้นมีอยู่อย่างรวบรัดในข้อความที่ตัดตอนมาจากเอกสาร Numpy.correlate:

mode : {'valid', 'same', 'full'}, optional
    Refer to the `convolve` docstring.  Note that the default
    is `valid`, unlike `convolve`, which uses `full`.

นี่หมายความว่าเมื่อใช้โดยไม่มีนิยาม 'โหมด' ฟังก์ชัน Numpy.correlate จะส่งกลับสเกลาร์เมื่อกำหนดเวกเตอร์เดียวกันสำหรับอาร์กิวเมนต์อินพุตสองตัว (กล่าวคือ - เมื่อใช้เพื่อดำเนินการสัมพันธ์อัตโนมัติ)

Question 13

วิธีง่ายๆโดยไม่ต้องแพนด้า:

import numpy as np

def auto_corrcoef(x):
   return np.corrcoef(x[1:-1], x[2:])[0,1]

Question 14

พล็อตความสัมพันธ์อัตโนมัติทางสถิติโดยให้ชุดข้อมูลวันเวลาของแพนด้า:

import matplotlib.pyplot as plt

def plot_autocorr(returns, lags):
    autocorrelation = []
    for lag in range(lags+1):
        corr_lag = returns.corr(returns.shift(-lag)) 
        autocorrelation.append(corr_lag)
    plt.plot(range(lags+1), autocorrelation, '--o')
    plt.xticks(range(lags+1))
    return np.array(autocorrelation)