foto av elena koycheva på unsplash

i denne praktiske opplæringen vil vi dekke temaet tidsseriemodellering med autoregressive prosesser.

denne artikkelen vil dekke følgende hovedelementer i tidsserieanalyse:

• autoregressiv prosess
• Yule-Walker ligning
• stasjonaritet
• Augmented Dicker-Fuller test

Sørg for å ha En Jupyter notatbok klar til å følge med. Koden og datasettet er tilgjengelig her.

La oss komme i gang!

Lær hvordan du arbeider med mer komplekse modeller SOM SARIMAX, VARMAX, og bruk dype læringsmodeller (LSTM, CNN, ResNet, autoregressive LSTM) for tidsserieanalyse med Anvendt Tidsserieanalyse i Python!

Autoregressiv Prosess

en autoregressiv modell bruker en lineær kombinasjon av tidligere verdier av målet for å lage prognoser. Selvfølgelig er regresjonen gjort mot målet selv. Matematisk er EN AR(p) – modell uttrykt som:

div>

hvor:

• p: er rekkefølgen
• c: er en konstant
• epsilon: ar(p) – modellen er utrolig fleksibel og kan modellere mange forskjellige typer tidsseriemønstre. Dette er lett visualisert når vi simulerer autoregressive prosesser.

  vanligvis brukes autoregressive modeller bare på stasjonære tidsserier. Dette begrenser rekkevidden av parametrene phi.

  FOR eksempel vil EN AR(1) – modell begrense phi mellom -1 og 1. Disse begrensningene blir mer komplekse etter hvert som modellens rekkefølge øker, men de vurderes automatisk når modellering i Python.

  Simulering AV EN AR(2) prosess

  la oss simulere EN AR(2) prosess I Python.

  vi starter med å importere noen biblioteker. Ikke alle vil bli brukt til simuleringen, men de vil være påkrevd for resten av denne opplæringen.

  from statsmodels.graphics.tsaplots import plot_pacf
  from statsmodels.graphics.tsaplots import plot_acf
  from statsmodels.tsa.arima_process import ArmaProcess
  from statsmodels.tsa.stattools import pacf
  from statsmodels.regression.linear_model import yule_walker
  from statsmodels.tsa.stattools import adfuller
  import matplotlib.pyplot as plt
  import numpy as np%matplotlib inline

  Vi vil bruke ArmaProcess-biblioteket til å simulere tidsserien. Det krever at vi definerer våre parametere.

  vi vil simulere følgende prosess:

  

  AR(2) prosess

  siden vi har å gjøre med en autoregressiv modell av ordre 2, må vi definere koeffisienten ved lag 0, 1 og 2.

  vi vil også avbryte effekten av en glidende gjennomsnittsprosess.

  Til Slutt vil vi generere 10 000 datapunkter.

  i kode:

  ar2 = np.array()
  ma = np.array()simulated_AR2_data = ArmaProcess(ar2, ma).generate_sample(nsample=10000)

  vi kan plotte tidsserien:

  plt.figure(figsize=); # Set dimensions for figure
  plt.plot(simulated_AR2_data)
  plt.title("Simulated AR(2) Process")
  plt.show()

  And you should get something similar to this:

  

  Now, let’s take a look at the autocorrelation plot (correlogram):

  plot_acf(simulated_AR2_data);

  

  / div>

  du kan se at koeffisienten sakte forfaller. Dette betyr at det er usannsynlig en glidende gjennomsnittsprosess, og det antyder at tidsserien sannsynligvis kan modelleres med en autoregressiv prosess (som er fornuftig siden det vi simulerer).

  for å sikre at dette er riktig, la oss plotte den delvise autokorrelasjonsplottet:

  plot_pacf(simulated_AR2_data);

  

  div>

  som du kan se er koeffisientene ikke signifikante etter lag 2. Derfor er den delvise autokorrelasjonsplottet nyttig for å bestemme rekkefølgen AV EN AR (p) – prosess.

  du kan også sjekke verdiene for hver koeffisient ved å kjøre:

  pacf_coef_AR2 = pacf(simulated_AR2_data)
  print(pacf_coef_AR2)

  Nå, i en ekte prosjektinnstilling, kan det være enkelt å finne rekkefølgen PÅ EN AR (p) – prosess, men vi må finne en måte å estimere koeffisientene phi.

  for å gjøre det bruker Vi yule-Walker-ligningen. Disse ligningene tillater oss å estimere koeffisientene TIL EN AR (p) – modell, gitt at vi kjenner rekkefølgen.

  rho, sigma = yule_walker(simulated_AR2_data, 2, method='mle')
  print(f'rho: {-rho}')
  print(f'sigma: {sigma}')

  

  som du kan se, yule-walker ligningen gjorde en anstendig jobb på å estimere våre koeffisienter og fikk svært nær 0,33 og 0,5.

  Simulering AV EN AR(3) prosess

  la Oss nå simulere EN AR (3) prosess. Spesielt vil vi simulere:

  

  på samme måte som det som tidligere ble gjort, la oss definere koeffisientene våre og generere 10 000 datapunkter:

  ar3 = np.array()
  ma = np.array()simulated_AR3_data = ArmaProcess(ar3,ma).generate_sample(nsample=10000)

  da kan vi visualisere tidsserien:

  plt.figure(figsize=); # Set dimensions for figure
  plt.plot(simulated_AR3_data)
  plt.title("Simulated AR(3) Process")
  plt.show()

  og du bør se noe som ligner på:

  

  Now, looking at the PACF and ACF:

  plot_pacf(simulated_AR3_data);
  plot_acf(simulated_AR3_data);

  

  You see that the coefficients are not significant after lag 3 for the PACF function as expected.

  Finally, let’s use the Yule-Walker equation to estimate the coefficients:

  rho, sigma = yule_walker(simulated_AR3_data, 3, method='mle')
  print(f'rho: {-rho}')
  print(f'sigma: {sigma}')

  

  igjen er estimatene ganske nær de faktiske verdiene.

  Prosjekt-Prognoser kvartalsvis EPS For Johnson &Johnson

  la Oss nå bruke vår kunnskap om autoregressive prosesser i en prosjektinnstilling.

  målet er å modellere kvartalsvis resultat per aksje (EPS) Av Selskapet Johnson&Johnson mellom 1960 og 1980.

  la Oss først lese datasettet:

  import pandas as pddata = pd.read_csv('jj.csv')
  data.head()

  

  nå er de første fem radene ikke veldig nyttige for oss. La oss plotte hele datasettet for å få en bedre visuell representasjon.

  plt.figure(figsize=); # Set dimensions for figure
  plt.scatter(data, data)
  plt.title('Quaterly EPS for Johnson & Johnson')
  plt.ylabel('EPS per share ($)')
  plt.xlabel('Date')
  plt.xticks(rotation=90)
  plt.grid(True)
  plt.show()

  

  quaterly eps for johnson&johnson mellom 1960 og 1980

  fantastisk! Nå kan vi det er klart oppover trend i dataene. Selv om dette kan være et godt tegn for selskapet, er det ikke bra når det gjelder tidsseriemodellering, siden det betyr at tidsserien ikke er stasjonær.

  SOM nevnt, FUNGERER AR(p) prosessen bare for stasjonære serier.

  Derfor må vi bruke noen transformasjoner til dataene våre for å gjøre det stasjonært.

  i dette tilfellet vil ta loggforskjellen. Dette tilsvarer å ta loggen for hver verdi, og trekke den forrige verdien.

  # Take the log difference to make data stationarydata = np.log(data)
  data = data.diff()
  data = data.drop(data.index)
  data.head()

  Plotting av transformerte tidsserier:

  plt.figure(figsize=); # Set dimensions for figure
  plt.plot(data)
  plt.title("Log Difference of Quaterly EPS for Johnson & Johnson")
  plt.show()

  

  div>

  nå ser det ut til at vi fjernet trenden. Vi må imidlertid være sikre på at serien vår er stasjonær før modellering med EN AR (p) prosess.

  vi vil dermed bruke augmented Dicker-Fuller test. Dette vil gi oss den statistiske tilliten til at vår tidsserie faktisk er stasjonær.

  ad_fuller_result = adfuller(data)
  print(f'ADF Statistic: {ad_fuller_result}')
  print(f'p-value: {ad_fuller_result}')

  

  / div>

  siden vi får en stor negativ adf-statistikk og p-verdi mindre enn 0,05, kan vi avvise nullhypotesen og si at vår tidsserie er stasjonær.

  Nå, la oss finne rekkefølgen av prosessen ved å plotte PACF:

  plot_pacf(data);
  plot_acf(data);

  

  som du kan se, etter lag 4, er pacf-koeffisientene ikke signifikante lenger. Derfor vil vi anta en autoregressiv prosess av ordre 4.

  nå vil vi bruke denne informasjonen til å estimere koeffisientene ved Hjelp Av yule-Walker-ligningen:

  # Try a AR(4) model
  rho, sigma = yule_walker(data, 4)
  print(f'rho: {-rho}')
  print(f'sigma: {sigma}')

  

  Therefore, the function is approximated as:

  

  Note that this equation models the transformed series.

  Conclusion

  Congratulations! Du forstår nå hva en autoregressiv modell er, hvordan du gjenkjenner en autoregressiv prosess, hvordan du bestemmer rekkefølgen, og hvordan du bruker den til å modellere en real-life tidsserie.

  Skjerp dine tidsserieanalyseferdigheter og lær de nyeste beste praksisene for tidsserieanalyse i Python:

  • Anvendt Tidsserieanalyse i Python

  Cheers 🍺