!pip install git+https://github.com/Techtonique/mlsauce.git --verbose

!pip install nnetsauce

!pip install git+https://github.com/thierrymoudiki/sktime.git --upgrade --no-cache-dir

import numpy as np
import pandas as pd
import statsmodels.api as sm

from sklearn import linear_model
from statsmodels.tsa.base.datetools import dates_from_str
from sktime.forecasting.nnetsaucemts import NnetsauceMTS

# some example data
mdata = sm.datasets.macrodata.load_pandas().data
# prepare the dates index
dates = mdata[["year", "quarter"]].astype(int).astype(str)
quarterly = dates["year"] + "Q" + dates["quarter"]
quarterly = dates_from_str(quarterly)
mdata = mdata[["realgovt", "tbilrate", "cpi"]]
mdata.index = pd.DatetimeIndex(quarterly)
data = np.log(mdata).diff().dropna()
data2 = mdata

n = data.shape[0]
max_idx_train = np.floor(n * 0.9)
training_index = np.arange(0, max_idx_train)
testing_index = np.arange(max_idx_train, n)
df_train = data.iloc[training_index, :]
print(df_train.tail())
df_test = data.iloc[testing_index, :]
print(df_test.head())

n2 = data.shape[0]
max_idx_train2 = np.floor(n2 * 0.9)
training_index2 = np.arange(0, max_idx_train2)
testing_index2 = np.arange(max_idx_train2, n2)
df_train2 = data2.iloc[training_index2, :]
print(df_train2.tail())
df_test2 = data2.iloc[testing_index, :]
print(df_test.head())

regr = linear_model.RidgeCV()

obj_MTS = NnetsauceMTS(regr, lags = 20, n_hidden_features=7, n_clusters=2,
                       type_pi="scp2-block-bootstrap",
                       kernel="gaussian",
                       replications=250)
obj_MTS.fit(df_train)

res = obj_MTS.predict(fh=[i for i in range(1, 20)])

print(res)

res = obj_MTS.predict_quantiles(fh=[i for i in range(1, 20)],
                                alpha=0.05)

print(res)

obj_MTS.fitter.plot(series="realgovt")

obj_MTS.fitter.plot(series="cpi")

# Do imports
import nnetsauce as ns
import mlsauce as ms
from sktime.forecasting.ttm import TinyTimeMixerForecaster
from sktime.forecasting.chronos import ChronosForecaster

# Initialise models
chronos = ChronosForecaster("amazon/chronos-t5-tiny")
ttm = TinyTimeMixerForecaster()
regr = linear_model.RidgeCV()
obj_MTS = NnetsauceMTS(regr, lags = 20, n_hidden_features=7, n_clusters=2,
                       type_pi="scp2-block-bootstrap",
                       kernel="gaussian",
                       replications=250)
regr2 = ms.GenericBoostingRegressor(regr)
obj_MTS2 = ns.MTS(obj=regr2)

# Fit
h = df_test.shape[0] + 1
chronos.fit(y=df_train, fh=range(1, h))
ttm.fit(y=df_train, fh=range(1, h))
obj_MTS.fit(y=df_train, fh=range(1, h))
obj_MTS2.fit(df_train)

# Predict
pred_chronos = chronos.predict(fh=[i for i in range(1, h)])
pred_ttm = ttm.predict(fh=[i for i in range(1, h)])
pred_MTS = obj_MTS.predict(fh=[i for i in range(1, h)])
pred_MTS2 = obj_MTS2.predict(h=h-1)

pred_MTS2 = obj_MTS2.predict(h=h-1)

import numpy as np

def rmse(predictions, targets):
    return np.sqrt(((predictions.values - targets.values) ** 2).mean())

def mae(predictions, targets):
    return np.mean(np.abs(predictions - targets))

def me(predictions, targets):
    return np.mean(predictions - targets)

print("Chronos RMSE:", rmse(df_test, pred_chronos))
print("Chronos MAE:", mae(df_test, pred_chronos))
print("Chronos ME:", me(df_test, pred_chronos))

print("TinyTimeMixer RMSE:", rmse(df_test, pred_ttm))
print("TinyTimeMixer MAE:", mae(df_test, pred_ttm))
print("TinyTimeMixer ME:", me(df_test, pred_ttm))

print("NnetsauceMTS RMSE:", rmse(df_test, pred_MTS))
print("NnetsauceMTS MAE:", mae(df_test, pred_MTS))
print("NnetsauceMTS ME:", me(df_test, pred_MTS))

from sklearn.utils import all_estimators
from sklearn.base import RegressorMixin
from tqdm import tqdm

results = []

results.append(["Chronos", rmse(df_test, pred_chronos), mae(df_test, pred_chronos), me(df_test, pred_chronos)])
results.append(["TinyTimeMixer", rmse(df_test, pred_ttm), mae(df_test, pred_ttm), me(df_test, pred_ttm)])
results.append(["NnetsauceMTS", rmse(df_test, pred_MTS), mae(df_test, pred_MTS), me(df_test, pred_MTS)])

# statistical models
for i, name in enumerate(["ARIMA", "ETS", "Theta", "VAR", "VECM"]):
  try:
    regr = ns.ClassicalMTS(model=name)
    regr.fit(df_train)
    X_pred = regr.predict(h=df_test.shape[0])
    results.append([name, rmse(df_test, X_pred.mean), mae(df_test, X_pred.mean), me(df_test, X_pred.mean)])
  except Exception:
    pass

for est in tqdm(all_estimators()):
  if (issubclass(est[1], RegressorMixin)):
    try:
      preds = ns.MTS(est[1](), verbose=0, show_progress=False).\
      fit(df_train).\
      predict(h=df_test.shape[0])
      results.append([est[0], rmse(df_test, preds), mae(df_test, preds), me(df_test, preds)])
    except Exception:
      pass

results_df = pd.DataFrame(results, columns=["model", "rmse", "mae", "me"])

import pandas as pd

# Assuming 'results_df' is the DataFrame from the provided code
pd.options.display.float_format = '{:.5f}'.format
display(results_df.sort_values(by="rmse"))

display(results_df.sort_values(by="mae"))

display(results_df.sort_values(by="me", ascending=False))

url = "https://raw.githubusercontent.com/Techtonique/"
url += "datasets/main/time_series/univariate/"
url += "a10.csv"
data = pd.read_csv(url)
data.index = pd.DatetimeIndex(data.date) # must have
data.drop(columns=['date'], inplace=True)

n = data.shape[0]
max_idx_train = np.floor(n * 0.9)
training_index = np.arange(0, max_idx_train)
testing_index = np.arange(max_idx_train, n)
df_train = data.iloc[training_index, :]
print(df_train.tail())
df_test = data.iloc[testing_index, :]
print(df_test.head())

df_train.plot()

# Do imports
import nnetsauce as ns
import mlsauce as ms
from sktime.forecasting.ttm import TinyTimeMixerForecaster
from sktime.forecasting.chronos import ChronosForecaster

# Initialise models
chronos = ChronosForecaster("amazon/chronos-t5-tiny")
ttm = TinyTimeMixerForecaster()
regr = linear_model.RidgeCV()
regr2 = ms.GenericBoostingRegressor(regr)
obj_MTS2 = ns.MTS(obj=regr2)

# Fit
h = df_test.shape[0] + 1
chronos.fit(y=df_train, fh=range(1, h))
ttm.fit(y=df_train, fh=range(1, h))
obj_MTS.fit(y=df_train, fh=range(1, h))
obj_MTS2.fit(df_train)

# Predict
pred_chronos = chronos.predict(fh=[i for i in range(1, h)])
pred_ttm = ttm.predict(fh=[i for i in range(1, h)])
pred_MTS2 = obj_MTS2.predict(h=h-1)

print("Chronos RMSE:", rmse(df_test, pred_chronos))
print("Chronos MAE:", mae(df_test, pred_chronos))
print("Chronos ME:", me(df_test, pred_chronos))

print("TinyTimeMixer RMSE:", rmse(df_test, pred_ttm))
print("TinyTimeMixer MAE:", mae(df_test, pred_ttm))
print("TinyTimeMixer ME:", me(df_test, pred_ttm))

print("NnetsauceMTS RMSE:", rmse(df_test, pred_MTS2))
print("NnetsauceMTS MAE:", mae(df_test, pred_MTS2))
print("NnetsauceMTS ME:", me(df_test, pred_MTS2))

from sklearn.utils import all_estimators
from sklearn.base import RegressorMixin
from tqdm import tqdm

results = []

# LLMs and sktime
results.append(["Chronos", rmse(df_test, pred_chronos), mae(df_test, pred_chronos), me(df_test, pred_chronos)])
results.append(["TinyTimeMixer", rmse(df_test, pred_ttm), mae(df_test, pred_ttm), me(df_test, pred_ttm)])
results.append(["NnetsauceMTS", rmse(df_test, pred_MTS), mae(df_test, pred_MTS), me(df_test, pred_MTS)])

# statistical models
for i, name in enumerate(["ARIMA", "ETS", "Theta", "VAR", "VECM"]):
  try:
    regr = ns.ClassicalMTS(model=name)
    regr.fit(df_train)
    X_pred = regr.predict(h=df_test.shape[0])
    results.append([name, rmse(df_test, X_pred.mean), mae(df_test, X_pred.mean), me(df_test, X_pred.mean)])
  except Exception:
    pass

for est in tqdm(all_estimators()):
  if (issubclass(est[1], RegressorMixin)):
    try:
      preds = ns.MTS(est[1](), lags=20, verbose=0, show_progress=False).\
      fit(df_train).\
      predict(h=df_test.shape[0])
      results.append([est[0], rmse(df_test, preds), mae(df_test, preds), me(df_test, preds)])
    except Exception:
      pass

results_df = pd.DataFrame(results, columns=["model", "rmse", "mae", "me"])

import pandas as pd

# Assuming 'results_df' is the DataFrame from the provided code
pd.options.display.float_format = '{:.5f}'.format
display(results_df.sort_values(by="rmse"))

display(results_df.sort_values(by="mae"))

display(results_df.sort_values(by="me"))