Python stattools.acf函数代码示例

 def __init__(self):
     self.x = np.concatenate((np.array([np.nan]), self.x))
     self.acf = self.results["acvar"]  # drop and conservative
     self.qstat = self.results["Q1"]
     self.res_drop = acf(self.x, nlags=40, qstat=True, alpha=0.05, missing="drop")
     self.res_conservative = acf(self.x, nlags=40, qstat=True, alpha=0.05, missing="conservative")
     self.acf_none = np.empty(40) * np.nan  # lags 1 to 40 inclusive
     self.qstat_none = np.empty(40) * np.nan
     self.res_none = acf(self.x, nlags=40, qstat=True, alpha=0.05, missing="none")

 def setup_class(cls):
     cls.x = np.concatenate((np.array([np.nan]),cls.x))
     cls.acf = cls.results['acvar'] # drop and conservative
     cls.qstat = cls.results['Q1']
     cls.res_drop = acf(cls.x, nlags=40, qstat=True, alpha=.05,
                         missing='drop')
     cls.res_conservative = acf(cls.x, nlags=40, qstat=True, alpha=.05,
                                 missing='conservative')
     cls.acf_none = np.empty(40) * np.nan # lags 1 to 40 inclusive
     cls.qstat_none = np.empty(40) * np.nan
     cls.res_none = acf(cls.x, nlags=40, qstat=True, alpha=.05,
                     missing='none')

 def __init__(self):
     self.x = np.concatenate((np.array([np.nan]),self.x))
     self.acf = self.results['acvar'] # drop and conservative
     self.qstat = self.results['Q1']
     self.res_drop = acf(self.x, nlags=40, qstat=True, alpha=.05, 
                         missing='drop')
     self.res_conservative = acf(self.x, nlags=40, qstat=True, alpha=.05, 
                                 missing='conservative')       
     self.acf_none = np.empty(40) * np.nan # lags 1 to 40 inclusive
     self.qstat_none = np.empty(40) * np.nan
     self.res_none = acf(self.x, nlags=40, qstat=True, alpha=.05,
                     missing='none')

 def SlowDecay():
     r = abs(np.sum(df.replace(np.inf, np.nan).replace(-np.inf, np.nan).fillna(0), axis=1) / len(df.columns))
     r = abs(df['AAPL'].replace(np.inf, np.nan).replace(-np.inf, np.nan).dropna(0))[:1000000]
     r1 = (np.sum(df.replace(np.inf, np.nan).replace(-np.inf, np.nan).fillna(0), axis=1) / len(df.columns))
     r1 = (df['AAPL'].replace(np.inf, np.nan).replace(-np.inf, np.nan).dropna(0))
     acf1, conf = acf(pd.DataFrame(r), alpha=0.05, nlags=20)
     acf2, conf2 = acf(pd.DataFrame(r1), alpha=0.05, nlags=20)
     plt.plot(acf1, label='ACF Absolute Returns')
     plt.plot(acf2, label='ACF Returns')
     plt.fill_between(range(len(acf1)), [i[0] for i in conf], [i[1] for i in conf], alpha=0.3)
     plt.fill_between(range(len(acf1)), [i[0] for i in conf2], [i[1] for i in conf2], alpha=0.3)
     plt.legend(loc='best')
     plt.savefig('Graphs/PACFAbsReturns.pdf', bbox_inches='tight')

    def fit(self, data):

        magnitude = data[0]
        AC = stattools.acf(magnitude, nlags=self.nlags)
        k = next((index for index, value in
                 enumerate(AC) if value < np.exp(-1)), None)

        while k is None:
            self.nlags = self.nlags + 100
            AC = stattools.acf(magnitude, nlags=self.nlags)
            k = next((index for index, value in
                      enumerate(AC) if value < np.exp(-1)), None)

        return k

def plot_acf(data):
    nlags = 90
    lw = 2
    x = range(nlags+1)

    plt.figure(figsize=(6, 4))
    plt.plot(x, acf(data['VIX']**2, nlags=nlags), lw=lw, label='VIX')
    plt.plot(x, acf(data['RV']**2, nlags=nlags), lw=lw, label='RV')
    plt.plot(x, acf(data['logR'], nlags=nlags), lw=lw, label='logR')
    plt.legend()
    plt.xlabel('Lags, days')
    plt.grid()
    plt.savefig('../plots/autocorr_logr_vix_rv.eps',
                bbox_inches='tight', pad_inches=.05)
    plt.show()

	def calc_autocorr(self):
		'''
		Calculate the autocorrelation of an array.
		'''
		nlags = int(self.fs / self._minfreq)
		self.acorr = acf(self._windowed(self.s2), nlags=nlags)
		self.acorr_freq = self.fs / np.arange(self.acorr.size)

def PrintSerialCorrelations(dailies):
    """Prints a table of correlations with different lags.

    dailies: map from category name to DataFrame of daily prices
    """
    filled_dailies = {}
    for name, daily in dailies.items():
        filled_dailies[name] = FillMissing(daily, span=30)

    # print serial correlations for raw price data
    for name, filled in filled_dailies.items():            
        corr = thinkstats2.SerialCorr(filled.ppg, lag=1)
        print(name, corr)

    rows = []
    for lag in [1, 7, 30, 365]:
        row = [str(lag)]
        for name, filled in filled_dailies.items():            
            corr = thinkstats2.SerialCorr(filled.resid, lag)
            row.append('%.2g' % corr)
        rows.append(row)

    print(r'\begin{tabular}{|c|c|c|c|}')
    print(r'\hline')
    print(r'lag & high & medium & low \\ \hline')
    for row in rows:
        print(' & '.join(row) + r' \\')
    print(r'\hline')
    print(r'\end{tabular}')

    filled = filled_dailies['high']
    acf = smtsa.acf(filled.resid, nlags=365, unbiased=True)
    print('%0.3f, %0.3f, %0.3f, %0.3f, %0.3f' % 
          (acf[0], acf[1], acf[7], acf[30], acf[365]))

def plot_acf_multiple(ys, lags=20):
    """

    """
    from statsmodels.tsa.stattools import acf
    # hack
    old_size = mpl.rcParams['font.size']
    mpl.rcParams['font.size'] = 8

    plt.figure(figsize=(10, 10))
    xs = np.arange(lags + 1)

    acorr = np.apply_along_axis(lambda x: acf(x, nlags=lags), 0, ys)

    k = acorr.shape[1]
    for i in range(k):
        ax = plt.subplot(k, 1, i + 1)
        ax.vlines(xs, [0], acorr[:, i])

        ax.axhline(0, color='k')
        ax.set_ylim([-1, 1])

        # hack?
        ax.set_xlim([-1, xs[-1] + 1])

    mpl.rcParams['font.size'] = old_size

def SimulateAutocorrelation(daily, iters=1001, nlags=40):
    """Resample residuals, compute autocorrelation, and plot percentiles.

    daily:
    iters:
    nlags:
    """
    # run simulations
    t = []
    for i in range(iters):
        filled = FillMissing(daily, span=30)
        resid = thinkstats2.Resample(filled.resid)
        acf = smtsa.acf(resid, nlags=nlags, unbiased=True)[1:]
        t.append(np.abs(acf))

    # put the results in an array and sort the columns
    size = iters, len(acf)
    array = np.zeros(size)
    for i, acf in enumerate(t):
        array[i,] = acf
    array = np.sort(array, axis=0)

    # find the bounds that cover 95% of the distribution
    high = PercentileRow(array, 97.5)
    low = -high
    lags = range(1, nlags+1)
    thinkplot.FillBetween(lags, low, high, alpha=0.2, color='gray')

def acf_fcn(data,lags=2,alpha=.05):
    #@FORMAT: data = np(values)
    try:
        acfvalues, confint,qstat,pvalues = acf(data,nlags=lags,qstat=True,alpha=alpha)
        return [acfvalues,pvalues]
    except:
        return [np.nan]

 def ACF_PACF_plot(self):
     #plot ACF and PACF to find the number of terms needed for the AR and MA in ARIMA
     # ACF finds MA(q): cut off after x lags 
     # and PACF finds AR (p): cut off after y lags 
     # in ARIMA(p,d,q) 
     lag_acf = acf(self.ts_log_diff, nlags=20)
     lag_pacf = pacf(self.ts_log_diff, nlags=20, method='ols')
     
     #Plot ACF:
     ax=plt.subplot(121)
     plt.plot(lag_acf)
     ax.set_xlim([0,5])
     plt.axhline(y=0,linestyle='--',color='gray')
     plt.axhline(y= -1.96/np.sqrt(len(ts_log_diff)),linestyle='--',color='gray')
     plt.axhline(y= 1.96/np.sqrt(len(ts_log_diff)),linestyle='--',color='gray')
     plt.title('Autocorrelation Function')
     
     #Plot PACF:
     plt.subplot(122)
     plt.plot(lag_pacf)
     plt.axhline(y=0,linestyle='--',color='gray')
     plt.axhline(y= -1.96/np.sqrt(len(ts_log_diff)),linestyle='--',color='gray')
     plt.axhline(y=1.96/np.sqrt(len(ts_log_diff)),linestyle='--',color='gray')
     plt.title('Partial Autocorrelation Function')
     plt.tight_layout()

 def setup_class(cls):
     cls.acf = cls.results['acvar']
     #cls.acf = np.concatenate(([1.], cls.acf))
     cls.qstat = cls.results['Q1']
     cls.res1 = acf(cls.x, nlags=40, qstat=True, alpha=.05)
     cls.confint_res = cls.results[['acvar_lb','acvar_ub']].view((float,
                                                                         2))

def autocorrelation(x, *args, unbiased=True, nlags=None, fft=True, **kwargs):
    """
    Return autocorrelation function of signal `x`.

    Parameters
    ----------
    x: array_like
        A 1D signal.
    nlags: int
        The number of lags to calculate the correlation for (default .9*len(x))
    fft:  bool
        Compute the ACF via FFT.
    args, kwargs
        As accepted by `statsmodels.tsa.stattools.acf`.

    Returns
    -------
    acf: array
        Autocorrelation function.
    confint: array, optional
        Confidence intervals if alpha kwarg provided.
    """
    from statsmodels.tsa.stattools import acf
    if nlags is None:
        nlags = int(.9 * len(x))
    corr = acf(x, *args, unbiased=unbiased, nlags=nlags, fft=fft, **kwargs)
    return _significant_acf(corr, kwargs.get('alpha'))

def lpc(frame, order):
    """
    frame: windowed signal
    order: lpc order
    return from 0th to `order`th linear predictive coefficients
    """
    r = acf(frame, unbiased=False, nlags=order)
    return levinson_durbin(r, order)[0]