Alternatywa dla wyrównywanie wykładnicze państwowej modelu przestrzeni R w Pythonie/scikit/numpy

Question

w R mamy jeden dobry model prognozowania jak:

ets(y, model="ZZZ", damped=NULL, alpha=NULL, beta=NULL, gamma=NULL, 

phi=NULL, additive.only=FALSE, lambda=NULL, 

lower=c(rep(0.0001,3), 0.8), upper=c(rep(0.9999,3),0.98), 

opt.crit=c("lik","amse","mse","sigma","mae"), nmse=3, 

bounds=c("both","usual","admissible"), ic=c("aicc","aic","bic"), 

restrict=TRUE, allow.multiplicative.trend=FALSE, use.initial.values=FALSE, ...) 

w tej metodzie, jeśli możemy przypisać dowolną zmienną, to automatycznie dostaje typ sezonu trend & typ błędu podobnie jak model="ZZZ"/"AMA"/"MMZ", a niektóre czynniki są automatycznie dostosowywane, aby uzyskać dokładne wyniki.

• W Pythonie mamy coś podobnego do ets w obu pandy/numpy/scipy/scikit?

  Według moich badań:
  Ewma w pand jest podobna, ale musimy zakodować wszystkie parametry do tych stałych.
  W Holtwinter musimy napisać szczegółowe metody dla wszystkich rodzajów trendów i sezonów.

• Więc zamiast tego mamy gotowe funkcje, które pobierają dane z ramek danych jako wartości wejściowe i dostarczają wartości prognostyczne, bez zapisywania jakichkolwiek wewnętrznych funkcji dla samych parametrów?

• Dowolne precyzyjne modele regresji scikit/statsmodels?

Answer 1

Po przeszukaniu całego kawałka, nie znalazłem niczego, co wydaje się bardzo obiecujący jako ets alternatywa dla pytona. Są jednak pewne próby: StatsModels i pycast's Forecasting methods, które można sprawdzić, czy odpowiadają Twoim potrzebom.

Jedną z opcji, której można użyć w celu obejścia brakującej implementacji, jest uruchomienie skryptu R z Pythona przy użyciu modułu subprocess. Istnieje bardzo dobry artykuł o tym, jak to zrobić here.

W tym celu późniejszego: (. Ex my_forecast.R)

1. Musisz utworzyć skrypt R, który będzie oblicz (używając ets) i druku prognozy na zasadzie plik lub na stdout (z komendą cat()), aby móc z nich korzystać po uruchomieniu skryptu .

2. można uruchomić skrypt R ze skryptu Pythona następująco:

   import subprocess 
   
   # You need to define the command that will run the Rscript from the subprocess 
   command = 'Rscript' 
   path2script = 'path/to/my_forecast.R' 
   cmd = [command, path2script] 
   
   # Option 1: If your script prints to a file 
   subprocess.run(cmd) 
   f = open('path/to/created/file', 'r') 
   (...Do stuff from here...) 
   
   # Option 2: If your script prints to stdout 
   forecasts = subprocess.check_output(cmd, universal_newlines=True) 
   (...Do stuff from here...) 
   

   Można również dodać argumenty do cmd, które zostaną wykorzystane przez Rscript jako argumenty wiersza poleceń, co następuje:

   args = [arg0, arg1, ...] 
   
   cmd = [command, path2script] + args 
   Then pass cmd to the subprocess 
   

---

EDIT:

Znalazłem przykładową serię artykułów na temat prognozy Holt-Winters: part1, part2 i part3. Poza tym łatwe do zrozumienia analizy w tych wyrobach, Gregory Trubeckoj (autor) dostarczył kod Opracował:

początkowa trendu:

def initial_trend(series, slen): 
    sum = 0.0 
    for i in range(slen): 
     sum += float(series[i+slen] - series[i])/slen 
    return sum/slen 

# >>> initial_trend(series, 12) 
# -0.7847222222222222 

składniki wyjściowe sezonowe:

def initial_seasonal_components(series, slen): 
    seasonals = {} 
    season_averages = [] 
    n_seasons = int(len(series)/slen) 
    # compute season averages 
    for j in range(n_seasons): 
     season_averages.append(sum(series[slen*j:slen*j+slen])/float(slen)) 
    # compute initial values 
    for i in range(slen): 
     sum_of_vals_over_avg = 0.0 
     for j in range(n_seasons): 
      sum_of_vals_over_avg += series[slen*j+i]-season_averages[j] 
     seasonals[i] = sum_of_vals_over_avg/n_seasons 
    return seasonals 

# >>> initial_seasonal_components(series, 12) 
# {0: -7.4305555555555545, 1: -15.097222222222221, 2: -7.263888888888888, 
# 3: -5.097222222222222, 4: 3.402777777777778, 5: 8.069444444444445, 
# 6: 16.569444444444446, 7: 9.736111111111112, 8: -0.7638888888888887, 
# 9: 1.902777777777778, 10: -3.263888888888889, 11: -0.7638888888888887} 

Wreszcie algorytm:

def triple_exponential_smoothing(series, slen, alpha, beta, gamma, n_preds): 
    result = [] 
    seasonals = initial_seasonal_components(series, slen) 
    for i in range(len(series)+n_preds): 
     if i == 0: # initial values 
      smooth = series[0] 
      trend = initial_trend(series, slen) 
      result.append(series[0]) 
      continue 
     if i >= len(series): # we are forecasting 
      m = i - len(series) + 1 
      result.append((smooth + m*trend) + seasonals[i%slen]) 
     else: 
      val = series[i] 
      last_smooth, smooth = smooth, alpha*(val-seasonals[i%slen]) + (1-alpha)*(smooth+trend) 
      trend = beta * (smooth-last_smooth) + (1-beta)*trend 
      seasonals[i%slen] = gamma*(val-smooth) + (1-gamma)*seasonals[i%slen] 
      result.append(smooth+trend+seasonals[i%slen]) 
    return result 

# # forecast 24 points (i.e. two seasons) 
# >>> triple_exponential_smoothing(series, 12, 0.716, 0.029, 0.993, 24) 
# [30, 20.34449316666667, 28.410051892109554, 30.438122252647577, 39.466817731253066, ... 

Można umieścić je w pliku, ex: holtwinters.py w folderze o następującej strukturze:

forecast_folder 
| 
└── __init__.py 
| 
└── holtwinters.py 

Odtąd, to moduł Pythona, który można umieścić wewnątrz każdej struktury projektu chcesz i używać go w dowolnym miejscu wewnątrz tego projektu, po prostu importując go.