ACF и PACF Формула

Я хочу создать код для построения ACF и PACF из данных временных рядов. Так же, как этот сгенерированный сюжет из Minitab (ниже).

Я пытался найти формулу, но до сих пор не понимаю ее. Не могли бы вы рассказать мне формулу и как ее использовать, пожалуйста? Какова горизонтальная красная линия на графике ACF и PACF выше? Какая формула?

Спасибо,

автокорреляции

Соотношение между двумя переменными определяется как:$y_1, y_2$

$$\rho = \frac{\hbox{E}\left[(y_1-\mu_1)(y_2-\mu_2)\right]}{\sigma_1 \sigma_2} = \frac{\hbox{Cov}(y_1, y_2)}{\sigma_1 \sigma_2} \,,$$

где E - оператор ожидания, и - средние значения для а и - их стандартные отклонения.$\mu_1$$\mu_2$$y_1$$y_2$$\sigma_1, \sigma_2$

В контексте одной переменной, то есть автокорреляции , - исходный ряд, а - его запаздывающая версия. После приведенного выше определения выборочные автокорреляции порядка могут быть получены путем вычисления следующего выражения с наблюдаемым рядом , :$y_1$$y_2$$k=0,1,2,...$$y_t$$t=1,2,...,n$

$$\rho(k) = \frac{\frac{1}{n-k}\sum_{t=k+1}^n (y_t - \bar{y})(y_{t-k} - \bar{y})}{ \sqrt{\frac{1}{n}\sum_{t=1}^n (y_t - \bar{y})^2}\sqrt{\frac{1}{n-k}\sum_{t=k+1}^n (y_{t-k} - \bar{y})^2}} \,,$$

где - среднее значение выборки данных.$\bar{y}$

Частичные автокорреляции

Частичные автокорреляции измеряют линейную зависимость одной переменной после устранения влияния других переменных, которые влияют на обе переменные. Например, частичная автокорреляция порядка измеряет влияние (линейная зависимость) на после устранения влияния на и .$y_{t-2}$$y_t$$y_{t-1}$$y_t$$y_{t-2}$

Каждая частичная автокорреляция может быть получена в виде серии регрессий вида:

$$\tilde{y}_t = \phi_{21} \tilde{y}_{t-1} + \phi_{22} \tilde{y}_{t-2} + e_t \,,$$

где - исходная серия минус среднее значение выборки, . Оценка даст значение частичной автокорреляции порядка 2. При расширении регрессии на дополнительных лагов оценка последнего члена даст частичную автокорреляцию порядка .$\tilde{y}_t$$y_t - \bar{y}$$\phi_{22}$$k$$k$

Альтернативный способ вычисления частичных автокорреляций образца заключается в решении следующей системы для каждого порядка :$k$

$$\begin{eqnarray} \left(\begin{array}{cccc} \rho(0) & \rho(1) & \cdots & \rho(k-1) \\ \rho(1) & \rho(0) & \cdots & \rho(k-2) \\ \vdots & \vdots & \vdots & \vdots \\ \rho(k-1) & \rho(k-2) & \cdots & \rho(0) \\ \end{array}\right) \left(\begin{array}{c} \phi_{k1} \\ \phi_{k2} \\ \vdots \\ \phi_{kk} \\ \end{array}\right) = \left(\begin{array}{c} \rho(1) \\ \rho(2) \\ \vdots \\ \rho(k) \\ \end{array}\right) \,, \end{eqnarray}$$

где - пример автокорреляции. Это отображение между автокорреляциями образца и частичными автокорреляциями известно как рекурсия Дурбина-Левинсона . Этот подход относительно легко реализовать для иллюстрации. Например, в программном обеспечении R мы можем получить частичную автокорреляцию порядка 5 следующим образом:$\rho(\cdot)$

# sample data
x <- diff(AirPassengers)
# autocorrelations
sacf <- acf(x, lag.max = 10, plot = FALSE)$acf[,,1]
# solve the system of equations
res1 <- solve(toeplitz(sacf[1:5]), sacf[2:6])
res1
# [1]  0.29992688 -0.18784728 -0.08468517 -0.22463189  0.01008379
# benchmark result
res2 <- pacf(x, lag.max = 5, plot = FALSE)$acf[,,1]
res2
# [1]  0.30285526 -0.21344644 -0.16044680 -0.22163003  0.01008379
all.equal(res1[5], res2[5])
# [1] TRUE

Полосы доверия

Полосы достоверности могут быть вычислены как значение автокорреляции образца , где - квантиль в распределении Гаусса, например, 1,96 для 95% доверительных интервалов.$\pm \frac{z_{1-\alpha/2}}{\sqrt{n}}$$z_{1-\alpha/2}$$1-\alpha/2$

Иногда используются доверительные интервалы, которые увеличиваются с увеличением порядка. В этом случае полосы могут быть определены как .$\pm z_{1-\alpha/2}\sqrt{\frac{1}{n}\left(1 + 2\sum_{i=1}^k \rho(i)^2\right)}$

«Я хочу создать код для построения ACF и PACF из данных временных рядов».

Хотя OP немного расплывчатый, он может быть более нацелен на формулировку кодирования в стиле «рецепт», чем на формулировку модели линейной алгебры.

---

ACF довольно проста: мы имеем временной ряд, и в основном делают несколько «копий» (как в «скопировать и вставить») из него, понимая , что каждая копия будет компенсировано одной записи из предыдущего экземпляра, так как исходные данные содержат точек данных, тогда как предыдущая длина временного ряда (исключая последнюю точку данных) составляет только . Мы можем сделать практически столько же копий, сколько строк. Каждая копия соотносится с оригиналом, имея в виду, что нам нужны идентичные длины, и для этого нам нужно будет обрезать хвостовую часть исходных рядов данных, чтобы сделать их сопоставимыми. Например, чтобы соотнести исходные данные с нам нужно избавиться от последних$t$$t-1$$ts_{t-3}$$3$данные точек исходного временного ряда (первые хронологическом порядке).$3$

Пример:

Мы создадим временные ряды с циклическим синусоидальным шаблоном, наложенным на линию тренда, и шумом, и построим R, сгенерированный ACF. Я взял этот пример из интернет-сообщения Кристофа Шербера и просто добавил к нему шум:

x=seq(pi, 10 * pi, 0.1)
y = 0.1 * x + sin(x) + rnorm(x)
y = ts(y, start=1800)

Обычно мы должны были бы проверить данные на стационарность (или просто посмотреть на график выше), но мы знаем, что в этом есть тенденция, поэтому давайте пропустим эту часть и перейдем непосредственно к шагу устранения тенденций:

model=lm(y ~ I(1801:2083))
st.y = y - predict(model)

Теперь мы готовы взять этот временной ряд, сначала сгенерировав ACF с acf()функцией в R, а затем сравнив результаты с временным циклом, который я собрал:

ACF = 0                  # Starting an empty vector to capture the auto-correlations.
ACF[1] = cor(st.y, st.y) # The first entry in the ACF is the correlation with itself (1).
for(i in 1:30){          # Took 30 points to parallel the output of `acf()`
  lag = st.y[-c(1:i)]    # Introducing lags in the stationary ts.
  clipped.y = st.y[1:length(lag)]    # Compensating by reducing length of ts.
  ACF[i + 1] = cor(clipped.y, lag)   # Storing each correlation.
}
acf(st.y)                            # Plotting the built-in function (left)
plot(ACF, type="h", main="ACF Manual calculation"); abline(h = 0) # and my results (right).

---

OK. Это было успешно. На PACF . Гораздо сложнее взломать ... Идея состоит в том, чтобы снова клонировать начальные значения несколько раз, а затем выбрать несколько временных точек. Однако вместо того, чтобы просто коррелировать с начальным временным рядом, мы собираем все промежуточные лаги и проводим регрессионный анализ, чтобы можно было исключить (контролировать) дисперсию, объясненную предыдущими временными точками. Например, если мы фокусируемся на окончании в момент времени , мы сохраняем , , и , а также , и мы регресс через$ts_{t-4}$$ts_t$$ts_{t-1}$$ts_{t-2}$$ts_{t-3}$$ts_{t-4}$$ts_t \sim ts_{t-1} + ts_{t-2} + ts_{t-3}+ts_{t-4}$ Происхождение и сохранение только коэффициента для :$ts_{t-4}$

PACF = 0          # Starting up an empty storage vector.
for(j in 2:25){   # Picked up 25 lag points to parallel R `pacf()` output.
  cols = j        
  rows = length(st.y) - j + 1 # To end up with equal length vectors we clip.

  lag = matrix(0, rows, j)    # The storage matrix for different groups of lagged vectors.

for(i in 1:cols){
  lag[ ,i] = st.y[i : (i + rows - 1)]  #Clipping progressively to get lagged ts's.
}
  lag = as.data.frame(lag)
  fit = lm(lag$V1 ~ . - 1, data = lag) # Running an OLS for every group.
  PACF[j] = coef(fit)[j - 1]           # Getting the slope for the last lagged ts.
}

И, наконец, построение графиков снова и снова, сгенерированные R и ручные вычисления:

То, что идея верна, кроме возможных вычислительных проблем, можно увидеть в сравнении PACFс pacf(st.y, plot = F).

---

код здесь .

Что ж, на практике мы обнаружили ошибку (шум), которая представлена ​​как доверительные полосы помогают вам определить, можно ли рассматривать уровень как только шум (потому что около 95% будет в полосах).$e_t$

Вот код Python для вычисления ACF:

def shift(x,b):
    if ( b <= 0 ):
        return x
    d = np.array(x);
    d1 = d
    d1[b:] = d[:-b]
    d1[0:b] = 0
    return d1

# One way of doing it using bare bones
# - you divide by first to normalize - because corr(x,x) = 1
x = np.arange(0,10)
xo = x - x.mean()

cors = [ np.correlate(xo,shift(xo,i))[0]  for i in range(len(x1)) ]
print (cors/cors[0] )

#-- Here is another way - you divide by first to normalize
cors = np.correlate(xo,xo,'full')[n-1:]
cors/cors[0]