diff --git a/v0_1_pure_pytorch/data_loader.py b/v0_1/data_loader.py similarity index 100% rename from v0_1_pure_pytorch/data_loader.py rename to v0_1/data_loader.py diff --git a/v0_1_pure_pytorch/example.py b/v0_1/example.py similarity index 100% rename from v0_1_pure_pytorch/example.py rename to v0_1/example.py diff --git a/v0_1_pure_pytorch/model.py b/v0_1/model.py similarity index 100% rename from v0_1_pure_pytorch/model.py rename to v0_1/model.py diff --git a/v0_1_pure_pytorch/training.py b/v0_1/training.py similarity index 100% rename from v0_1_pure_pytorch/training.py rename to v0_1/training.py diff --git a/v0_1_pure_pytorch/utils.py b/v0_1/utils.py similarity index 100% rename from v0_1_pure_pytorch/utils.py rename to v0_1/utils.py diff --git a/v1_0/ar_net.py b/v1_0/ar_net.py new file mode 100644 index 0000000..4e7ae06 --- /dev/null +++ b/v1_0/ar_net.py @@ -0,0 +1,229 @@ +import os +## lazy imports ala fastai2 style (for nice print functionality) +from fastai2.basics import * +from fastai2.tabular.all import * +## explicit imports (for reference) +# from fastai2.basics import Callback +# from fastai2.data.core import DataLoaders +# from fastai2.learner import Metric +# from fastai2.metrics import mse, mae +# from fastai2.tabular.core import TabularPandas, TabDataLoader +# from fastai2.tabular.learner import tabular_learner +# from fastai2.torch_core import to_detach +# from fastai2.data.transforms import Normalize +## import my own code +from make_dataset import load_from_file, tabularize_univariate +from utils import pad_ar_params, estimate_noise, split_by_p_valid, nice_print_list, compute_sTPE, coeff_from_model +from plotting import plot_weights, plot_prediction_sample, plot_error_scatter + + +class SparsifyAR(Callback): + """Callback that adds regularization of first linear layer according to AR-Net paper""" + def __init__(self, est_sparsity, est_noise=1.0, reg_strength=0.02): + self.lam = 0.0 + if est_sparsity is not None: + self.lam = reg_strength * est_noise * (1.0 / est_sparsity - 1.0) + def after_loss(self): + if not self.training: return + abs_weights = None + for layer in self.learn.model.modules(): + if isinstance(layer, torch.nn.Linear): + abs_weights = torch.abs(layer.weight) + break + if abs_weights is None: + raise NotImplementedError("weight regualarization only implemented for model with Linear layer") + reg = torch.div(2.0, 1.0 + torch.exp(-3.0 * abs_weights.pow(1.0 / 3.0))) - 1.0 + self.learn.loss += self.lam * torch.mean(reg) + _docs = dict(after_loss="Add regularization of first linear layer") + + +class sTPE(Metric): + """" + Symmetrical Total Percentage Error of learned weights compared to underlying AR coefficients. + Computed as the average over snapshots at each batch. + """ + def __init__(self, ar_params, at_epoch_end=False): + self.ar_params = ar_params + self.at_epoch_end = at_epoch_end + def reset(self): + self.total, self.count = 0., 0 + self.sTPE = None + def accumulate(self, learn): + self.sTPE = to_detach(compute_sTPE( + est=coeff_from_model(model=learn.model, reversed_weights=True), + real=self.ar_params + )) + self.total += self.sTPE + self.count += 1 + @property + def value(self): + if self.at_epoch_end: + return self.sTPE + return self.total/self.count if self.count != 0 else None + @property + def name(self): return "sTPE of AR coeff" + + +def init_ar_learner(series, ar_order, n_forecasts=1, valid_p=0.1, sparsity=None, ar_params=None, verbose=False): + df_all = tabularize_univariate(series, ar_order, n_forecasts) + est_noise = estimate_noise(series) + + if verbose: + print("tabularized df") + print("df columns", list(df_all.columns)) + print("df shape", df_all.shape) + # if nested_list: print("x_dim:", len(df_all['x'][0]), "y_dim:", len(df_all['y'][0])) + # print("df head(3)", df_all.head(3)) + print("estimated noise of series", est_noise) + + ## split + splits = split_by_p_valid(valid_p, len(df_all), verbose) + + cont_names = [col for col in list(df_all.columns) if "x_" == col[:2]] + target_names = [col for col in list(df_all.columns) if "y_" == col[:2]] + + ## preprocess? + # procs = [Normalize] # Note: not AR if normalized, need to unnormalize then again. + procs = [] + + tp = TabularPandas( + df_all, + procs=procs, + cat_names=None, + cont_names=cont_names, + y_names=target_names, + splits=splits + ) + if verbose: + print("cont var num", len(tp.cont_names), tp.cont_names) + # print(tp.iloc[0:5]) + + ### next: data loader, learner + trn_dl = TabDataLoader(tp.train, bs=32, shuffle=True, drop_last=True) + val_dl = TabDataLoader(tp.valid, bs=128) + dls = DataLoaders(trn_dl, val_dl) + + # if verbose: + # print("showing batch") + # print(dls.show_batch(show=False)) + + callbacks = [] + if sparsity is not None: + callbacks.append(SparsifyAR(sparsity, est_noise)) + if verbose: print("reg lam: ", callbacks[0].lam) + + metrics = [mae] + if ar_params is not None: + metrics.append(sTPE(ar_params, at_epoch_end=False)) + + learn = tabular_learner( + dls, + layers=[], # Note: None defaults to [200, 100] + # config = None, # None calls tabular_config() + n_out=len(target_names), # None calls get_c(dls) + use_bn=False, # passed to TabularModel + bn_final=False, # passed to TabularModel + bn_cont=False, # passed to TabularModel + metrics=metrics, # passed on to TabularLearner, to parent Learner + loss_func=mse, + cbs=callbacks + ) + if verbose: + print(learn.model) + return learn + + +def main(verbose=False): + """example of how to use AR-Net""" + save = True + created_ar_data = True + + data_path = 'ar_data' + data_name = 'ar_3_ma_0_noise_0.100_len_10000' + results_path = 'results' + + ## Load data + if created_ar_data: + ## if created AR data with create_ar_data, we can use the helper function: + df, data_config = load_from_file(data_path, data_name, load_config=True, verbose=verbose) + else: + ## else we can manually load any file that stores a time series, for example: + df = pd.read_csv(os.path.join(data_path, data_name + '.csv'), header=None, index_col=False) + + #### Hyperparameters + n_epoch = 20 + valid_p = 0.5 + n_forecasts = 1 # Note: must have a list of ar_param for each forecast target. + sparsity = 0.3 # guesstimate + ar_order = 10 # guesstimate + + ar_params = None + ## if we know the true AR parameters: + if created_ar_data: + ## for normal AR: + ar_order = int(data_config["ar_order"]) + ## for sparse AR: + ar_order = int(1 / sparsity * data_config["ar_order"]) + ## to compute stats + ar_params = pad_ar_params([data_config["ar_params"]], ar_order, n_forecasts) + + #### Init Model + learn = init_ar_learner( + series=df, + ar_order=ar_order, + n_forecasts=n_forecasts, + valid_p=valid_p, + sparsity=sparsity, + ar_params=ar_params, + verbose=verbose, + ) + + #### Run Model + ## find Learning Rate + lr_at_min, lr_steepest = learn.lr_find(start_lr=1e-6, end_lr=1e2, num_it=400, show_plot=False) + if verbose: print("lr_at_min", lr_at_min) + ## if you know the best learning rate: + # learn.fit(n_epoch, 1e-2) + ## else use onecycle + learn.fit_one_cycle(n_epoch=n_epoch, lr_max=lr_at_min/10) + + learn.recorder.plot_loss() + + #### Analysis of results + coeff = coeff_from_model(learn.model) + if created_ar_data: print("ar params", nice_print_list(ar_params)) + print("model weights", nice_print_list(coeff)) + # should be [0.20, 0.30, -0.50, ...] + + if created_ar_data: + plot_weights( + ar_val=len(ar_params[0]), + weights=coeff[0], + ar=ar_params[0], + save=save, + savedir=results_path + ) + preds, y = learn.get_preds() + plot_prediction_sample(preds, y, num_obs=100, save=save, savedir=results_path) + plot_error_scatter(preds, y, save=save, savedir=results_path) + + #### Optional: save and create inference learner + if save: + learn.freeze() + if not os.path.exists(results_path): os.makedirs(results_path) + model_name = "ar{}_sparse_{:.3f}_ahead_{}_epoch_{}.pkl".format(ar_order, sparsity, n_forecasts, n_epoch) + learn.export(fname=os.path.join(results_path, model_name)) + ## can be loaded like this + infer = load_learner(fname=os.path.join(results_path, model_name), cpu=True) + + #### Optional: can unfreeze the model and fine_tune + learn.unfreeze() + learn.fit_one_cycle(10, lr_at_min/100) + ## check if improved + coeff2 = coeff_from_model(learn.model) + if created_ar_data: print("ar params", nice_print_list(ar_params)) + print("model weights", nice_print_list(coeff)) + print("model weights2", nice_print_list(coeff2)) + +if __name__ == '__main__': + main(verbose=True) diff --git a/v1_0/create_ar_data.py b/v1_0/create_ar_data.py new file mode 100644 index 0000000..479a607 --- /dev/null +++ b/v1_0/create_ar_data.py @@ -0,0 +1,134 @@ +import os +import json +import numpy as np +import pandas as pd +from statsmodels.tsa.arima_process import ArmaProcess + + +def _get_config(noise_std=0.1, n_samples=10000, random_ar_params=True): + # option 1: Randomly generated AR parameters + data_config_random = { + "noise_std": noise_std, + "ar_order": 3, + "ma_order": 0, + "params": None, # for randomly generated AR params + } + data_config_random["samples"] = n_samples #+ int(data_config_random["ar_order"]) + # option 2: Manually define AR parameters + data_config_manual = { + "noise_std": noise_std, + "params": ([0.2, 0.3, -0.5], []), + # "params": ([0.2, 0, 0.3, 0, 0, 0, 0, 0, 0, -0.5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], []), + } + data_config_manual["ar_order"] = int(sum(np.array(data_config_manual["params"][0]) != 0.0)) + data_config_manual["ma_order"] = int(sum(np.array(data_config_manual["params"][1]) != 0.0)) + data_config_manual["samples"] = n_samples #+ int(data_config_manual["ar_order"]) + return data_config_random if random_ar_params else data_config_manual + + +def _generate_random_arparams(ar_order, ma_order, limit_abs_sum=True, maxiter=100): + is_stationary = False + iteration = 0 + while not is_stationary: + iteration += 1 + # print("Iteration", iteration) + if iteration > maxiter: + raise RuntimeError("failed to find stationary coefficients") + # Generate random parameters + arparams = [] + maparams = [] + for i in range(ar_order): + arparams.append(2 * np.random.random() - 1) + for i in range(ma_order): + maparams.append(2 * np.random.random() - 1) + # print(arparams) + arparams = np.array(arparams) + maparams = np.array(maparams) + if limit_abs_sum: + ar_abssum = sum(np.abs(arparams)) + ma_abssum = sum(np.abs(maparams)) + if ar_abssum > 1: + arparams = arparams / (ar_abssum + 10e-6) + arparams = arparams * (0.5 + 0.5*np.random.random()) + if ma_abssum > 1: + maparams = maparams / (ma_abssum + 10e-6) + maparams = maparams * (0.5 + 0.5*np.random.random()) + + arparams = arparams - np.mean(arparams) + maparams = maparams - np.mean(maparams) + arma_process = ArmaProcess.from_coeffs(arparams, maparams, nobs=100) + is_stationary = arma_process.isstationary + return arparams, maparams + + +def generate_armaprocess_data(samples, ar_order, ma_order, noise_std, params=None): + if params is not None: + # use specified params (make sure to sum up to 1 or less) + arparams, maparams = params + else: + # iterate to find random arparams that are stationary + arparams, maparams = _generate_random_arparams(ar_order, ma_order) + arma_process = ArmaProcess.from_coeffs(arparams, maparams, nobs=samples) + # sample output from ARMA Process + series = arma_process.generate_sample(samples, scale=noise_std) + # make zero-mean: + series = series - np.mean(series) + return series, arparams, maparams + + +def save_to_file(save_path, series, data_config): + if not os.path.exists(save_path): + os.makedirs(save_path) + file_data = "ar_{}_ma_{}_noise_{:.3f}_len_{}".format( + data_config["ar_order"], data_config["ma_order"], data_config["noise_std"], data_config["samples"]) + np.savetxt(os.path.join(save_path, file_data + '.csv'), series, delimiter=',') + with open(os.path.join(save_path, "info_" + file_data + '.json'), 'w') as f: + json.dump(data_config, f) + return file_data + + +def load_from_file(data_path, data_name, load_config=True, verbose=False): + df = pd.read_csv(os.path.join(data_path, data_name + '.csv'), header=None, index_col=False) + if load_config: + with open(os.path.join(data_path, "info_" + data_name + '.json'), 'r') as f: + data_config = json.load(f) + else: + data_config = None + if verbose: + print("loaded series from file") + print("data_config", data_config) + print(df.shape) + print(df.head()) + return df, data_config + + +def main(): + verbose = True + random = False + save = True + save_path = 'ar_data' + + data_config = _get_config(random_ar_params=random) + if verbose: + print(data_config) + + series, data_config["ar_params"], data_config["ma_params"] = generate_armaprocess_data(**data_config) + del data_config["params"] + + if save: + data_name = save_to_file(save_path, series, data_config) + + # just to test: + df, data_config2 = load_from_file(save_path, data_name, load_config=True) + if verbose: + print("loaded from saved files:") + print(data_config2) + print(df.head()) + + +if __name__ == '__main__': + main() + + + + diff --git a/v1_0/example_ar_net.ipynb b/v1_0/example_ar_net.ipynb new file mode 100644 index 0000000..204ac33 --- /dev/null +++ b/v1_0/example_ar_net.ipynb @@ -0,0 +1,730 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "## lazy imports ala fastai2 style (for nice print functionality)\n", + "from fastai2.basics import *\n", + "from fastai2.tabular.all import *\n", + "\n", + "## import my own code\n", + "from make_dataset import load_from_file, tabularize_univariate\n", + "from utils import pad_ar_params, estimate_noise, split_by_p_valid, nice_print_list\n", + "from utils import compute_sTPE, coeff_from_model\n", + "from plotting import plot_weights, plot_prediction_sample, plot_error_scatter\n", + "from ar_net import init_ar_learner\n", + "\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "## notebook settings\n", + "verbose = True\n", + "save = True\n", + "created_ar_data = True\n", + "\n", + "data_path = '../ar_data'\n", + "data_name = 'ar_3_ma_0_noise_0.100_len_10000'\n", + "results_path = '../results'" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loaded series from file\n", + "data_config {'noise_std': 0.1, 'ar_order': 3, 'ma_order': 0, 'samples': 10000, 'ar_params': [0.2, 0.3, -0.5], 'ma_params': []}\n", + "(10000, 1)\n", + " 0\n", + "0 -0.098078\n", + "1 -0.189121\n", + "2 0.074818\n", + "3 0.227776\n", + "4 0.219362\n" + ] + } + ], + "source": [ + "## Load data\n", + "if created_ar_data:\n", + " ## if created AR data with create_ar_data, we can use the helper function:\n", + " df, data_config = load_from_file(data_path, data_name, load_config=True, verbose=verbose)\n", + "else:\n", + " ## else we can manually load any file that stores a time series, for example:\n", + " df = pd.read_csv(os.path.join(data_path, data_name + '.csv'), header=None, index_col=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "#### Hyperparameters\n", + "n_epoch = 20\n", + "valid_p = 0.5\n", + "n_forecasts = 1 # Note: must have a list of ar_param for each forecast target.\n", + "sparsity = 0.3 # guesstimate\n", + "ar_order = 10 # guesstimate\n", + "\n", + "ar_params = None\n", + "## if we know the true AR parameters:\n", + "if created_ar_data: \n", + " ## for normal AR:\n", + " ar_order = int(data_config[\"ar_order\"])\n", + " ## for sparse AR:\n", + " ar_order = int(1/sparsity * data_config[\"ar_order\"]) \n", + " ## to compute stats\n", + " ar_params = pad_ar_params([data_config[\"ar_params\"]], ar_order, n_forecasts)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "10\n", + "tabularized df\n", + "df columns ['x_0', 'x_1', 'x_2', 'x_3', 'x_4', 'x_5', 'x_6', 'x_7', 'x_8', 'x_9', 'y_0']\n", + "df shape (9990, 11)\n", + "estimated noise of series 0.1274848566033341\n", + "split on idx: 4995\n", + "split sizes: [4995, 4995]\n", + "cont var num 10 (#10) ['x_0','x_1','x_2','x_3','x_4','x_5','x_6','x_7','x_8','x_9']\n", + "reg lam: 0.005949293308155593\n", + "TabularModel(\n", + " (embeds): ModuleList()\n", + " (emb_drop): Dropout(p=0.0, inplace=False)\n", + " (layers): Sequential(\n", + " (0): LinBnDrop(\n", + " (0): Linear(in_features=10, out_features=1, bias=True)\n", + " )\n", + " )\n", + ")\n" + ] + } + ], + "source": [ + "#### Init Model\n", + "learn = init_ar_learner(\n", + " series=df,\n", + " ar_order=ar_order,\n", + " n_forecasts=n_forecasts,\n", + " valid_p=valid_p,\n", + " sparsity=sparsity,\n", + " ar_params=ar_params,\n", + " verbose=verbose,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.13803842067718505\n" + ] + } + ], + "source": [ + "## find Learning Rate\n", + "lr_at_min, _ = learn.lr_find(start_lr=1e-6, end_lr=1e2, num_it=400)\n", + "print(lr_at_min)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
epochtrain_lossvalid_lossmaesTPE of AR coefftime
00.0566100.0336920.15547561.42483600:01
10.0169300.0100220.07979125.90227200:01
20.0135320.0099320.07959413.79615900:01
30.0128330.0102880.08102414.97677600:01
40.0129960.0100280.07978218.29583400:02
50.0131740.0099700.07961411.29647700:02
60.0131620.0099520.0796279.48251500:01
70.0136030.0101970.08051317.35119900:01
80.0132190.0099800.0798006.84455500:01
90.0130350.0101790.08033714.32602400:01
100.0130410.0099220.07946810.86305900:02
110.0130880.0099440.0795427.72456400:01
120.0128580.0099190.0795707.13529800:01
130.0131310.0098520.0791868.34259200:01
140.0124590.0098740.0793289.21381200:02
150.0126740.0098770.0793286.84691700:01
160.0122740.0098460.0791775.52221800:01
170.0122370.0098510.0791803.55940400:02
180.0118740.0098480.0791733.64759500:01
190.0119670.0098490.0791723.40584000:01
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#### Run Model\n", + "## if you know the best learning rate:\n", + "# learn.fit(n_epoch, 1e-2)\n", + "## else use onecycle\n", + "learn.fit_one_cycle(n_epoch=n_epoch, lr_max=lr_at_min/10)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "learn.recorder.plot_loss()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ar params [['0.200', '0.300', '-0.500', '0.000', '0.000', '0.000', '0.000', '0.000', '0.000', '0.000']]\n", + "model weights [['0.178', '0.270', '-0.488', '-0.000', '-0.000', '0.000', '-0.000', '-0.000', '-0.000', '-0.001']]\n" + ] + } + ], + "source": [ + "#### Look at Coeff\n", + "coeff = coeff_from_model(learn.model)\n", + "if created_ar_data: print(\"ar params\", nice_print_list(ar_params))\n", + "print(\"model weights\", nice_print_list(coeff))\n", + "# should be [0.20, 0.30, -0.50, ...]" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "if created_ar_data: \n", + " plot_weights(\n", + " ar_val=len(ar_params[0]),\n", + " weights=coeff[0],\n", + " ar=ar_params[0],\n", + " save=save,\n", + " savedir=results_path\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "preds, y = learn.get_preds()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_prediction_sample(preds, y, num_obs=100, save=save, savedir=results_path)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_error_scatter(preds, y, save=save, savedir=results_path)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "#### Extras ####" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "## Optional:save and create inference learner\n", + "if save:\n", + " learn.freeze()\n", + " if not os.path.exists(results_path): os.makedirs(results_path)\n", + " model_name = \"ar{}_sparse_{:.3f}_ahead_{}_epoch_{}.pkl\".format(ar_order, sparsity, n_forecasts, n_epoch)\n", + " learn.export(fname=os.path.join(results_path, model_name))\n", + " ## can be loaded like this\n", + " infer = load_learner(fname=os.path.join(results_path, model_name), cpu=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
epochtrain_lossvalid_lossmaesTPE of AR coefftime
00.0116160.0098470.0791653.47261900:02
10.0121950.0098520.0792214.13128300:02
20.0121360.0098650.0792494.40441300:01
30.0126790.0098500.0792264.28244600:01
40.0121880.0098460.0791904.00658000:01
50.0122260.0098580.0791883.63942400:02
60.0119830.0098550.0791823.35343300:02
70.0121000.0098560.0791893.23107300:02
80.0116920.0098510.0791743.05191200:01
90.0119250.0098510.0791742.96941800:01
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "## can unfreeze the model and fine_tune\n", + "learn.unfreeze()\n", + "learn.fit_one_cycle(10, lr_at_min/100)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "learn.recorder.plot_loss()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ar params [['0.200', '0.300', '-0.500', '0.000', '0.000', '0.000', '0.000', '0.000', '0.000', '0.000']]\n", + "model weights [['0.178', '0.270', '-0.488', '-0.000', '-0.000', '0.000', '-0.000', '-0.000', '-0.000', '-0.001']]\n", + "model weights2 [['0.180', '0.271', '-0.492', '-0.000', '0.000', '0.000', '0.000', '-0.000', '0.000', '0.000']]\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmkAAAFzCAYAAABl1J6yAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nO3deZiXdb3/8ecbULFSU0TDhUCzBAVHGzm5pBZi1DnH5WiJK1IeKTOz069zbLmy7VIKf8dj51gnfqKZC2qYRWUu4W6lsYwsoqEGipIo5h4m8P798b2BAWaGAeY79w3zfFzXXHMvn+/nft8zybz63MsnMhNJkiRVS7eyC5AkSdLaDGmSJEkVZEiTJEmqIEOaJElSBRnSJEmSKsiQJkmSVEE9yi6go+24447Zr1+/ssuQJElap6lTp76Qmb1b2rfZhbR+/foxZcqUssuQJElap4iY39o+L3dKkiRVkCFNkiSpggxpkiRJFbTZ3ZMmSdKm4K233mLBggUsWbKk7FLUCXr27Mluu+3GFlts0e7PGNIkSSrBggUL2GabbejXrx8RUXY5qqPMZPHixSxYsID+/fu3+3Ne7pQkqQRLliyhV69eBrQuICLo1avXeo+aGtIkSSqJAa3r2JDftSFNkiSVql+/frzwwgsb3WZzY0iTJEmqoFJDWkQMj4jHIuLxiDi/hf2fjoiZEdEUEfdHxMAy6pQkSaubN28ee++9N2eeeSb77rsvp5xyCr/97W855JBD2GuvvXjooYd48cUXOfbYYxk8eDAf+MAHmDFjBgCLFy/mqKOOYv/992f06NFk5sp+r7nmGoYMGUJDQwOjR49m2bJlZZ1i6UoLaRHRHbgM+CgwEDiphRB2XWYOyswG4HvAf3ZymZIkqRWPP/44n//855kxYwaPPvoo1113Hffffz8XX3wxF154IRdccAH7778/M2bM4MILL+T0008H4Jvf/CaHHnoo06dP5+ijj+app54CYM6cOdxwww088MADNDU10b17d6699toyT7FUZb6CYwjweGY+CRAR1wPHAI+saJCZrzRr/3YgkSRJldC/f38GDRoEwD777MPQoUOJCAYNGsS8efOYP38+N910EwAf/vCHWbx4MS+//DL33nsvP/vZzwD4x3/8R7bffnsAJk+ezNSpUznwwAMB+Nvf/sZOO+1UwplVQ5khbVfg6WbrC4B/WLNRRHwW+DdgS+DDLXUUEWcBZwH07du3wwvdFNTrCaHmQ9CSJDW31VZbrVzu1q3byvVu3bqxdOlSevRYO2as+HvV0t+tzGTkyJFcdNFFdap401LmPWktpYq1EkFmXpaZewL/AXytpY4yc1xmNmZmY+/evTu4TEmStCEOO+ywlZcr7777bnbccUe23Xbb1bb/5je/4a9//SsAQ4cOZeLEiSxatAiAF198kfnz55dTfAWUOZK2ANi92fpuwLNttL8e+GFdK5IkSR3mG9/4BqNGjWLw4MG87W1v46qrrgLgggsu4KSTTuKAAw7g8MMPX3kVbODAgXznO9/hqKOOYvny5WyxxRZcdtllvPvd7y7zNEoTZV3OiogewJ+AocAzwB+BkzNzdrM2e2Xm3GL5n4ELMrOxrX4bGxtzypQp9Su8orzcKUmbljlz5jBgwICyy1Anaul3HhFTW8s2pY2kZebSiDgHuA3oDlyRmbMj4lvAlMycBJwTEUcCbwF/BUaWVa8kSVJnKnWC9cy8BbhljW1fb7b8+U4vSpIkqQKccUCSJKmCDGmSJEkVZEiTJEmqIEOaJElSBRnSJEmSKqjUpztVfU99a1Bd+u379Zl16VeSNlUd/b7L9r7n8uabb+Zf/uVfmDNnDnvvvTcA8+bNY8CAAbzvfe/j73//O42NjYwfP54ttthirc+fccYZ3HPPPWy33XZ069aNyy67jIMOOqhDz6UjTJ8+ncsuu4xDDjmESy+9FIBHHnmE973vfXTv3p3hw4czZsyYjT7Oxz/+cb773e+yxx57bHRfjqRJktSFTZgwgUMPPZTrr79+te177rknTU1NzJw5kwULFnDjjTe22sfYsWNpampizJgxjB49eq39S5cu7fC619eFF17I5z73OUaNGkVTUxNNTU3ssssu3HXXXStrb25Da/70pz/N2LFjO6JkQ5okSV3Va6+9xgMPPMD48ePXCmkrdO/enSFDhvDMM8+ss7/DDjuMxx9/HIAjjjiCr3zlKxx++OFceumlzJ8/n6FDhzJ48GCGDh3KU089BcBzzz3Hcccdx3777cd+++3H7373OwCuueYahgwZQkNDA6NHj2bZsmUsW7aMM844g3333ZdBgwZxySWXAPD973+fgQMHMnjwYEaMGLFWXa+++iozZsxgv/32a7P+r33ta4wePZphw4YxatQoLr/8cs4777yV+4cPH879998P1OYcPeiggzjggAM48cQTef3111ee96233sqyZcvW+fNaF0OaJEld1M9//nOGDx/Oe9/7XnbYYQemTZu2VpslS5bw4IMPMnz48HX298tf/pJBg1bdJvPSSy9xzz338MUvfpFzzjmH008/nRkzZnDKKadw7rnnAnDuuedy+OGH8/DDDzNt2jT22Wcf5syZww033MADDzxAU1MT3bt359prr6WpqYlnnnmGWbNmMXPmTEaNGgXAmDFjmD59OjNmzOB///d/16prypQp7Lvvvu36mUyfPp1f/vKXXH311a22WbRoEWPGjGHy5MlMmzaNwYMHr7yE2r17d/r168esWbPadby2GNIkSeqiJkyYsHLkacSIEUyYMGHlvieeeIKGhgZ69epF3759GTx4cKv9fOlLX6KhoYFx48Yxfvz4ldtPPPHElcu///3vOfnkkwE47bTTVo5I3XnnnXzmM58BagFnu+22Y/LkyUydOpUDDzyQhoYGJk+ezJNPPskee+zBk08+yec+9zluvfVWtt12WwAGDx7MKaecwjXXXEOPHmvfbr9w4UJ69+7drp/JMcccQ8+ePdts87vf/Y5HHnmEgw8+mIaGBq699lrmzZu3cv9OO+3Es88+267jtcUHByRJ6oIWL17MnXfeyaxZs4gIli1bRkTwve99D1h1T9rChQs54ogjmDRpEkcffTSjRo1i+vTp7LLLLtxyS21mx7Fjx3LCCSesdYy3v/3trR6/rQclMpORI0dy0UUXrbXv4Ycf5rbbbuOyyy7jxhtv5IorruDXv/419957L5MmTeLb3/42s2fPXi2sbb311ixZsqRdP5fmNffo0YPly5evXF/RR2YyfPjwVkfblixZwtZbb92u47XFkTRJkrqgiRMncvrppzN//nzmzZvH008/Tf/+/VeOcK3Qp08fxowZszIwXXnllTQ1Na0MaO118MEHr7zv7dprr+XQQw8FYOjQofzwhz8EYNmyZbzyyisMHTqUiRMnsmjRIgBefPFF5s+fzwsvvMDy5cs5/vjj+fa3v820adNYvnw5Tz/9NB/60If43ve+x0svvcRrr7222rEHDBiw8l659dGvXz+mT59OZjJv3jymTp268lzuuecennzySQBef/115s6du/Jzc+fOZZ999lnv463JkCZJUgVkZod+rcuECRM47rjjVtt2/PHHc911163V9thjj+WNN97gvvvu2+Dz+/73v8+VV17J4MGDufrqq1few3XppZdy1113MWjQIN7//vcze/ZsBg4cyHe+8x2OOuooBg8ezLBhw1i4cCHPPPMMRxxxBA0NDZxxxhlcdNFFLFu2jFNPPZVBgwax//7784UvfIF3vvOdqx1777335uWXX+bVV19dr5oPP/xwdt11VwYNGsT5559PQ0MDADvvvDPjx4/nxBNPZL/99uPggw/mT3/6EwDPPvss2223Xbsvr7Yl2vselU1FY2NjTpkypewyOl1Hv19nhfnfbN+NluvL96RJ6urmzJnDgAEDyi6jy7jkkkvYZpttOPPMM+t6nLFjx7LTTjsxcuTItfa19DuPiKmZ2dhSX46kSZKkzd5nPvMZttpqq7ofp1evXpx66qkd0pcPDkiSpM1ez549Oe200+p+nE9+8pMd1pcjaZIkSRVkSJMkSaogQ5okSVIFGdIkSerCbr75ZiKCRx99FIB58+ax9dZb09DQwMCBAzn99NN56623WvzsGWecwa677sqbb74JwAsvvEC/fv3aPN5LL73ED37wgw49h82VDw5IklQBT31r0LobrYf2vupowoQJHHrooVx//fV84xvfAFbNNrBs2TKGDRvGjTfeyCmnnNLi57t3784VV1yxcmqndVkR0s4+++x2te/KHEmTJKmLeu2113jggQcYP378ytkAmuvevTtDhgzhmWeeabWP8847j0suuYSlS5eutW/s2LEceOCBDB48mAsuuACA888/f+W8oF/60pc67mQ2Q4Y0SZK6qJ///OcMHz6c9773veywww5MmzZttf1LlizhwQcfZPjw4a320bdvXw499NC15rG8/fbbmTt3Lg899BBNTU1MnTqVe++9lzFjxqwcqRs7dmxdzmtzYUiTJKmLmjBhAiNGjABgxIgRTJgwAWDlSFevXr3o27cvgwcPbrOfr3zlK4wdO3a1ychvv/12br/9dvbff38OOOAAHn300dXmt9S6eU+aJEld0OLFi7nzzjuZNWsWEcGyZcuICM4+++yVI10LFy7kiCOOYNKkSRx99NGMGjWK6dOns8suu6w2wfp73vMeGhoauPHGG1duy0y+/OUvM3r06NWOO2/evM46xU2eI2mSJHVBEydO5PTTT2f+/PnMmzePp59+mv79+7NgwYKVbfr06cOYMWO46KKLALjyyitpampaLaCt8NWvfpWLL7545fpHPvIRrrjiCl577TUAnnnmGRYtWsQ222yz3hOdd1WGNEmSuqAJEyZw3HHHrbbt+OOP58ILL1xt27HHHssbb7zBfffd12Z/++yzDwcccMDK9aOOOoqTTz6Zgw46iEGDBnHCCSfw6quv0qtXLw455BD23XdfHxxYh8jMsmvoUI2NjTllypSyy+h0EVGXfud/c9+69NveR8MlaXM1Z84cBgwYUHYZ6kQt/c4jYmpmNrbUvtSRtIgYHhGPRcTjEXF+C/v/LSIeiYgZETE5It5dRp2SJEmdrbSQFhHdgcuAjwIDgZMiYuAazaYDjZk5GJgIfK9zq5QkSSpHmSNpQ4DHM/PJzPw7cD1wTPMGmXlXZr5RrP4B2K2Ta5QkSSpFmSFtV+DpZusLim2t+RTwm7pWJElSJ9rc7gtX6zbkd13me9JautO9xTOIiFOBRuDwVvafBZwFtTcft9Jmg4pcF/8DkyRtiJ49e7J48WJ69epVt79RqobMZPHixfTs2XO9PldmSFsA7N5sfTfg2TUbRcSRwFeBwzPzzZY6ysxxwDioPd3Z8aVKktSxdtttNxYsWMDzzz9fdinqBD179mS33dbvrq0yQ9ofgb0ioj/wDDACOLl5g4jYH/gRMDwzF3V+iZIk1ccWW2xB//79yy5DFVbaPWmZuRQ4B7gNmAPcmJmzI+JbEXF00Wws8A7gpxHRFBGTSipXkiSpU5U6d2dm3gLcssa2rzdbPrLTi5IkSaoAp4WSJEmqIEOaJElSBZV6uXNz8NS3BtWtb+e3lCSp63IkTZIkqYIMaZIkSRVkSJMkSaogQ5okSVIFGdIkSZIqyJAmSZJUQYY0SZKkCjKkSZIkVZAhTZIkqYIMaZIkSRVkSJMkSaogQ5okSVIFGdIkSZIqyJAmSZJUQYY0SZKkCjKkSZIkVZAhTZIkqYIMaZIkSRVkSJMkSaogQ5okSVIFGdIkSZIqyJAmSZJUQYY0SZKkCjKkSZIkVZAhTZIkqYJKDWkRMTwiHouIxyPi/Bb2HxYR0yJiaUScUEaNkiRJZSgtpEVEd+Ay4KPAQOCkiBi4RrOngDOA6zq3OkmSpHL1KPHYQ4DHM/NJgIi4HjgGeGRFg8ycV+xbXkaBkiRJZSnzcueuwNPN1hcU2yRJkrq8MkNatLAtN6ijiLMiYkpETHn++ec3sixJkqTylRnSFgC7N1vfDXh2QzrKzHGZ2ZiZjb179+6Q4iRJkspUZkj7I7BXRPSPiC2BEcCkEuuRJEmqjNJCWmYuBc4BbgPmADdm5uyI+FZEHA0QEQdGxALg48CPImJ2WfVKkiR1pjKf7iQzbwFuWWPb15st/5HaZVBJkqQuxRkHJEmSKsiQJkmSVEGGNEmSpAoypEmSJFWQIU2SJKmCDGmSJEkVZEiTJEmqIEOaJElSBRnSJEmSKsiQJkmSVEGGNEmSpAoypEmSJFWQIU2SJKmCDGmSJEkVZEiTJEmqIEOaJElSBRnSJEmSKsiQJkmSVEGGNEmSpAoypEmSJFWQIU2SJKmCDGmSJEkVZEiTJEmqIEOaJElSBRnSJEmSKsiQJkmSVEGGNEmSpAoypEmSJFVQqSEtIoZHxGMR8XhEnN/C/q0i4oZi/4MR0a/zq5QkSep8pYW0iOgOXAZ8FBgInBQRA9do9ingr5n5HuAS4LudW6UkSVI5yhxJGwI8nplPZubfgeuBY9ZocwxwVbE8ERgaEdGJNUqSJJWizJC2K/B0s/UFxbYW22TmUuBloFenVCdJklSiHiUeu6URsdyANkTEWcBZAH379m3xYJlrfWyzsrmfX70GUOd/c9+69Nv36zPr0q8kqesocyRtAbB7s/XdgGdbaxMRPYDtgBfX7Cgzx2VmY2Y29u7du07lSpIkdZ52hbSI2D4i9omIPSKio4LdH4G9IqJ/RGwJjAAmrdFmEjCyWD4BuDM39yEjSZIk2rjcGRHbAZ8FTgK2BJ4HegI7R8QfgB9k5l0beuDMXBoR5wC3Ad2BKzJzdkR8C5iSmZOA8cDVEfE4tRG0ERt6PEmSpE1JW/ekTQR+AnwwM19qviMiGoFTI2KPzBy/oQfPzFuAW9bY9vVmy0uAj29o/5IkSZuqVkNaZg5rY98UYEpdKpIkSdK670mLiMnt2SZJkqSO09Y9aT2BtwE7RsT2rHodxrbALp1QmyRJUpfV1j1po4HzqAWyqawKaa9Qm85JkiRJddLWPWmXApdGxOcy8787sSZJkqQub50zDmTmf0fEwUC/5u0z8yd1rEuSJKlLW2dIi4irgT2BJmBZsTmpvZ5DkiRJddCeuTsbgYG+6V+SJKnztGeKp1nAu+pdiCRJklZp6xUcv6R2WXMb4JGIeAh4c8X+zDy6/uVJkiR1TW1d7ry406qQJEnSatp6Bcc9nVmIJEmSVmnP052vUrvs2dzL1Obu/GJmPlmPwiRJkrqy9jzd+Z/As8B11GYdGEHtQYLHgCuAI+pVnCRJUlfVnqc7h2fmjzLz1cx8JTPHAR/LzBuA7etcnyRJUpfUnpC2PCI+ERHdiq9PNNvnu9MkSZLqoD0h7RTgNGAR8FyxfGpEbA2cU8faJEmSuqz2zN35JPDPrey+v2PLkSRJErT9Mtt/z8zvRcR/08Jlzcw8t66VSZIkdWFtjaTNKb5P6YxCJEmStEpbL7P9ZfH9KoCIeHtmvt5ZhUmSJHVl63xwICIOiohHKEbWImK/iPhB3SuTJEnqwtrzdOd/AR8BFgNk5sPAYfUsSpIkqatrT0gjM59eY9OyOtQiSZKkQnumhXo6Ig4GMiK2BM5l1UMFkiRJqoP2jKR9GvgssCuwAGgo1iVJklQn7RlJey0zT6l7JZIkSVqpPSFtVkQ8B9wH3As8kJkv17csSZKkrm2dlzsz8z3AScBM4J+AhyOiaWMOGhE7RMQdETG3+L59K+1ujYiXIuJXG3M8SZKkTU173pO2G3AI8EFgf2A2cMNGHvd8YHJm7gVMLtZbMpbahO6SJEldSnsudz4F/BG4MDM/3UHHPQY4oli+Crgb+I81G2Xm5Ig4Ys3tkiRJm7v2PN25P/AT4OSI+H1E/CQiPrWRx905MxcCFN932sj+JEmSNivrHEnLzIcj4gngCWqXPE+lNuPA+LY+FxG/Bd7Vwq6vbkCdbYqIs4CzAPr27dvR3UuSJHW6dYa0iJgCbAX8DrgfOCwz56/rc5l5ZBt9PhcRfTJzYUT0ARatR80tHWscMA6gsbExN6YvSZKkKmjPPWkfzcznO/i4k4CRwJji+y86uH9JkqRNWqv3pEXEqRHRrbWAFhF7RsShG3jcMcCwiJgLDCvWiYjGiLi82THuA34KDI2IBRHxkQ08niRJ0ialrZG0XsD0iJgKTAWeB3oC7wEOB16g9VdntCkzFwNDW9g+BTiz2foHN6R/SZKkTV2rIS0zL42I/wE+TO09aYOBv1GbXP20zHyqc0qUJEnqetq8Jy0zlwF3FF+SJEnqJO15T5okSZI6mSFNkiSpggxpkiRJFdSeCdZ3jojxEfGbYn1gB0wLJUmSpDa0ZyTtx8BtwC7F+p+A8+pVkCRJktoX0nbMzBuB5QCZuRRYVteqJEmSurj2hLTXI6IXkAAR8QHg5bpWJUmS1MW1Z+7Of6M21+aeEfEA0Bs4oa5VSZIkdXHrDGmZOS0iDgfeBwTwWGa+VffKJEmSurB1hrSIOH2NTQdEBJn5kzrVJEmS1OW153Lngc2We1KbGH0aYEiTJEmqk/Zc7vxc8/WI2A64um4VSZIkaYNmHHgD2KujC5EkSdIq7bkn7ZcUr9+gFuoGAjfWsyhJkqSurj33pF3cbHkpMD8zF9SpHkmSJNG+e9Lu6YxCJEmStEqrIS0iXmXVZc7VdgGZmdvWrSpJkqQurtWQlpnbdGYhkiRJWqU996QBEBE7UXtPGgCZ+VRdKpIkSdK6X8EREUdHxFzgz8A9wDzgN3WuS5IkqUtrz3vSvg18APhTZvanNuPAA3WtSpIkqYtrT0h7KzMXA90ioltm3gU01LkuSZKkLq0996S9FBHvAO4Fro2IRdTelyZJkqQ6ac9I2jHUpoL6AnAr8ATwz/UsSpIkqatrz0jaWcBPi1kGrqpzPZIkSaJ9I2nbArdFxH0R8dmI2LneRUmSJHV16wxpmfnNzNwH+CywC3BPRPx2Yw4aETtExB0RMbf4vn0LbRoi4vcRMTsiZkTEiRtzTEmSpE1Je0bSVlgE/AVYDOy0kcc9H5icmXsBk4v1Nb0BnF4ExOHAf0XEOzfyuJIkSZuE9rzM9jMRcTe1MLUj8K+ZOXgjj3sMq+5vuwo4ds0GmfmnzJxbLD9LLST23sjjSpIkbRLa8+DAu4HzMrOpA4+7c2YuBMjMhcWUU62KiCHAltSeLJUkSdrsrTOkZWZLlyLXqbhv7V0t7PrqevbTB7gaGJmZy1tpcxa1p1Dp27fvelYqSZJUPe2eYH19ZeaRre2LiOciok8xitaH2qXMltptC/wa+Fpm/qGNY40DxgE0NjbmxlUuSZJUvvV5cKAjTQJGFssjgV+s2SAitgRuBn6SmT/txNokSZJKV1ZIGwMMi4i5wLBinYhojIjLizafAA4DzoiIpuLLOUMlSVKXULfLnW0pJmwf2sL2KcCZxfI1wDWdXJokSVIllDWSJkmSpDYY0iRJkirIkCZJklRBhjRJkqQKMqRJkiRVkCFNkiSpggxpkiRJFWRIkyRJqiBDmiRJUgUZ0iRJkirIkCZJklRBhjRJkqQKMqRJkiRVkCFNkiSpggxpkiRJFWRIkyRJqiBDmiRJUgUZ0iRJkirIkCZJklRBhjRJkqQKMqRJkiRVkCFNkiSpggxpkiRJFWRIkyRJqiBDmiRJUgUZ0iRJkirIkCZJklRBhjRJkqQKKiWkRcQOEXFHRMwtvm/fQpt3R8TUiGiKiNkR8ekyapUkSSpDWSNp5wOTM3MvYHKxvqaFwMGZ2QD8A3B+ROzSiTVKkiSVpqyQdgxwVbF8FXDsmg0y8++Z+WaxuhVempUkSV1IWcFn58xcCFB836mlRhGxe0TMAJ4GvpuZz3ZijZIkSaXpUa+OI+K3wLta2PXV9vaRmU8Dg4vLnD+PiImZ+VwLxzoLOAugb9++G1ixJElSddQtpGXmka3ti4jnIqJPZi6MiD7AonX09WxEzAY+CExsYf84YBxAY2NjblzlkiRJ5SvrcuckYGSxPBL4xZoNImK3iNi6WN4eOAR4rNMqlCRJKlFZIW0MMCwi5gLDinUiojEiLi/aDAAejIiHgXuAizNzZinVSpIkdbK6Xe5sS2YuBoa2sH0KcGaxfAcwuJNLkyRJqgRfayFJklRBhjRJkqQKMqRJkiRVkCFNkiSpggxpkiRJFWRIkyRJqiBDmiRJUgUZ0iRJkirIkCZJklRBhjRJkqQKMqRJkiRVkCFNkiSpggxpkiRJFWRIkyRJqiBDmiRJUgUZ0iRJkirIkCZJklRBhjRJkqQKMqRJkiRVkCFNkiSpggxpkiRJFWRIkyRJqiBDmiRJUgUZ0iRJkirIkCZJklRBhjRJkqQKMqRJkiRVkCFNkiSpgkoJaRGxQ0TcERFzi+/bt9F224h4JiL+pzNrlCRJKlNZI2nnA5Mzcy9gcrHemm8D93RKVZIkSRVRVkg7BriqWL4KOLalRhHxfmBn4PZOqkuSJKkSygppO2fmQoDi+05rNoiIbsD/Bb7UybVJkiSVrke9Oo6I3wLvamHXV9vZxdnALZn5dESs61hnAWcB9O3bd33KlCRJqqS6hbTMPLK1fRHxXET0ycyFEdEHWNRCs4OAD0bE2cA7gC0j4rXMXOv+tcwcB4wDaGxszI45A0mSpPLULaStwyRgJDCm+P6LNRtk5ikrliPiDKCxpYAmSZK0OSrrnrQxwLCImAsMK9aJiMaIuLykmiRJkiqjlJG0zFwMDG1h+xTgzBa2/xj4cd0LkyRJqghnHJAkSaogQ5okSVIFGdIkSZIqyJAmSZJUQYY0SZKkCjKkSZIkVZAhTZIkqYIMaZIkSRVkSJMkSaogQ5okSVIFGdIkSZIqyJAmSZJUQYY0SZKkCjKkSZIkVZAhTZIkqYIMaZIkSRVkSJMkSaogQ5okSVIFGdIkSZIqyJAmSZJUQYY0SZKkCjKkSZIkVZAhTZIkqYIMaZIkSRVkSJMkSaogQ5okSVIFGdIkSZIqyJAmSZJUQYY0SZKkCupRxkEjYgfgBqAfMA/4RGb+tYV2y4CZxepTmXl0Z9WorqHv12euu5EkSSUoayTtfGByZu4FTC7WW/K3zGwovv4PGtoAAAvySURBVAxokiSpyygrpB0DXFUsXwUcW1IdkiRJlVRWSNs5MxcCFN93aqVdz4iYEhF/iIhWg1xEnFW0m/L888/Xo16VLDPr8iVJUlXV7Z60iPgt8K4Wdn11Pbrpm5nPRsQewJ0RMTMzn1izUWaOA8YBNDY2+pdXkiRt8uoW0jLzyNb2RcRzEdEnMxdGRB9gUSt9PFt8fzIi7gb2B9YKaZIkSZubsi53TgJGFssjgV+s2SAito+IrYrlHYFDgEc6rUJJkqQSlRXSxgDDImIuMKxYJyIaI+Lyos0AYEpEPAzcBYzJTEOaJEnqEkp5T1pmLgaGtrB9CnBmsfw7YFAnlyZJklQJzjggSZJUQYY0SZKkCjKkSZIkVZAhTZIkqYIMaZIkSRVkSJMkSaogQ5okSVIFGdIkSZIqyJAmSZJUQZGZZdfQoSLieWB+Jx5yR+CFTjxeZ/P8Nm2e36Zrcz438Pw2dZ5fx3l3ZvZuacdmF9I6W0RMyczGsuuoF89v0+b5bbo253MDz29T5/l1Di93SpIkVZAhTZIkqYIMaRtvXNkF1Jnnt2nz/DZdm/O5gee3qfP8OoH3pEmSJFWQI2mSJEkVZEjbQBFxRUQsiohZZddSDxGxe0TcFRFzImJ2RHy+7Jo6UkT0jIiHIuLh4vy+WXZNHS0iukfE9Ij4Vdm1dLSImBcRMyOiKSKmlF1PR4uId0bExIh4tPhv8KCya+ooEfG+4ve24uuViDiv7Lo6SkR8ofg3ZVZETIiInmXX1JEi4vPFuc3eHH5vLf0tj4gdIuKOiJhbfN++rPoMaRvux8Dwsouoo6XAFzNzAPAB4LMRMbDkmjrSm8CHM3M/oAEYHhEfKLmmjvZ5YE7ZRdTRhzKzoQqPydfBpcCtmbk3sB+b0e8xMx8rfm8NwPuBN4CbSy6rQ0TErsC5QGNm7gt0B0aUW1XHiYh9gX8FhlD73+U/RcRe5Va10X7M2n/LzwcmZ+ZewORivRSGtA2UmfcCL5ZdR71k5sLMnFYsv0rtj8Su5VbVcbLmtWJ1i+Jrs7lBMyJ2A/4RuLzsWrR+ImJb4DBgPEBm/j0zXyq3qroZCjyRmZ35AvJ66wFsHRE9gLcBz5ZcT0caAPwhM9/IzKXAPcBxJde0UVr5W34McFWxfBVwbKcW1YwhTesUEf2A/YEHy62kYxWXA5uARcAdmbk5nd9/Af8OLC+7kDpJ4PaImBoRZ5VdTAfbA3geuLK4XH15RLy97KLqZAQwoewiOkpmPgNcDDwFLARezszby62qQ80CDouIXhHxNuBjwO4l11QPO2fmQqgNWAA7lVWIIU1tioh3ADcB52XmK2XX05Eyc1lxyWU3YEgxlL/Ji4h/AhZl5tSya6mjQzLzAOCj1C7FH1Z2QR2oB3AA8MPM3B94nRIvt9RLRGwJHA38tOxaOkpx79IxQH9gF+DtEXFquVV1nMycA3wXuAO4FXiY2q0xqhNDmloVEVtQC2jXZubPyq6nXopLSXez+dxjeAhwdETMA64HPhwR15RbUsfKzGeL74uo3c80pNyKOtQCYEGzkd2J1ELb5uajwLTMfK7sQjrQkcCfM/P5zHwL+BlwcMk1dajMHJ+ZB2TmYdQuE84tu6Y6eC4i+gAU3xeVVYghTS2KiKB2T8yczPzPsuvpaBHROyLeWSxvTe0f10fLrapjZOaXM3O3zOxH7XLSnZm52fy/+Yh4e0Rss2IZOIraZZjNQmb+BXg6It5XbBoKPFJiSfVyEpvRpc7CU8AHIuJtxb+hQ9mMHvoAiIidiu99gX9h8/sdAkwCRhbLI4FflFVIj7IOvKmLiAnAEcCOEbEAuCAzx5dbVYc6BDgNmFnctwXwlcy8pcSaOlIf4KqI6E7t/6zcmJmb3asqNlM7AzfX/gbSA7guM28tt6QO9zng2uKS4JPAqJLr6VDF/UzDgNFl19KRMvPBiJgITKN2GXA6FXlzfQe6KSJ6AW8Bn83Mv5Zd0MZo6W85MAa4MSI+RS14f7y0+pxxQJIkqXq83ClJklRBhjRJkqQKMqRJkiRVkCFNkiSpggxpkiRJFWRIk9SqiDguIjIi9m62rV9E/C0imiLikYj4SfHi43rWcW5EzImIayNiq4j4bXH8E4tpkwa28dmjI2KD3tgfEe+MiLPb2L91RNxTTDHWLyIq/b62iDgjIv5nI/u4fjOYVFvaJBjSJLXlJOB+ai/Fbe6JYkqtQdSm1fpEnes4G/hYZp5CbR7ZLTKzITNvyMwzM7PVl71m5qTMHLOBx31ncezWfBL4WWYu28D+NynFewV/SG1eWEl1ZkiT1KJi3tZDgE+xdkgDavOfAg8Bu7bSx3uKUa+HI2JaROwZNWMjYlZEzIyIE5u1/1JE/DEiZkTEN4tt/0tt0vFJEfEfwDVAQzGStmdE3B0RjUXb4cVxHo6IycW2laNHxUwTNxXH+GNEHFJs/0ZEXFH09WREnFuUNAbYszjW2BZO8RRaeBt5Map2X1HLtIg4uNjeLSJ+EBGzI+JXEXFLRJzQwufvjojvRsRDEfGniPjgmudSrP8qIo4oll8rPjO1+JkPaXY+RzfrfveIuDUiHouIC5r1dWpxvKaI+FERyFb0+62IeBA4CLgPODIifBm6VGf+RyapNccCt2bmnyLixYg4IDOnNW8QET2BfwA+30of1wJjMvPmom03alPJNAD7ATsCf4yIe6mNyu1FbR7OoBbKDsvMT0fEcOBDmflCERb+T2b+U1HDilp6A/8POCwz/xwRO7RQz6XAJZl5f9SmtbkNGFDs2xv4ELAN8FhE/JDaxOb7FqOGq4nabAB7ZOa8Fo6zCBiWmUuKS4MTgMbi3PsV57oTtSmDrmjlZ9cjM4dExMeovQX9yFbarfB24O7M/I+IuBn4DrW3+g8ErqI21Q3Ufr77Am9Q+9n/mtok7idSm7j+rYj4AbUA+pOi31mZ+fVm5/44td/f1HXUJGkjGNIkteYk4L+K5euL9RUhbc+oTRe2FzAxM2es+eGoza+5a2beDJCZS4rthwITilG45yLiHuBA4DBq83BOL7p4R9H/ve2s9wPAvZn55+J4L7bQ5khg4IpgB2xb1Anw68x8E3gzIhZRm36qLTsCL7WybwvgfyKiAVgGvLfYfijw08xcDvwlIu5qo/+fFd+nUgt26/J3YMX0WDOBN4vANXONz9+RmYsBIuJnRU1LgfdTC20AW7NqUullwE1rHGsRsAuGNKmuDGmS1hK1ufk+DOwbEQl0BzIiVtyL9ERmNkREH+DuiDg6MydFxJXU7hl7llYukVIbJWtt+0WZ+aMNLRtY1zx33YCDMvNvq32wFkzebLZpGev+9/FvQM9W9n0BeI7aaFM3YEmzGttrRT3Na1nK6repND/+W7lqnr/lKz6fmcvXuDS55s8oi7quyswvt1DHkhbuuetJ7fwl1ZH3pElqyQnATzLz3ZnZLzN3B/5MbdRlpcxcSO2S4JeL9VHFDf0fy8xXgAURcSxA1J7KfBu1kbETo/ZEZG9qI2gPUbv0+MniXjgiYteI2Gk9av49cHhE9C8+39LlztuBc1asFCNdbXmV2uXPtRQTS3cvLuOuaTtgYTFidhq1kAu1hzCOL+5N25naxM7rYx61+/G6RcTu1C5drq9hEbFDRGxN7ZL2A8Bk4IQVP+9i/7vb6OO9wOwNOLak9WBIk9SSk4Cb19h2E3ByC21/Drxtxc3tazgNODciZgC/A95V9DsDeBi4E/j3zPxLZt4OXAf8vrhEN5FWAlJLMvN54CzgZxHxMHBDC83OBRqj9mDCI8Cn19HnYuCBqD3k0NKDA7ezRnAt/AAYGRF/oBZoXi+23wQsAGYBPwIeBF5e58mt8gC1sDwTuJhVl5/Xx/3A1UATcFNmTimejv0acHvxu7oD6NPSh4tw+bcioEuqo1g1Oi5JWh8RsT/wb5l52np85h2Z+VpxSfkhajfr/6VuRXawiPgC8Epmji+7Fmlz5z1pkrSBMnN6RNwVEd3X411pv4qIdwJbAt/elAJa4SVqI3GS6syRNEmSpArynjRJkqQKMqRJkiRVkCFNkiSpggxpkiRJFWRIkyRJqiBDmiRJUgX9f3eH2RwWsR1nAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "coeff2 = coeff_from_model(learn.model)\n", + "if created_ar_data: print(\"ar params\", nice_print_list(ar_params))\n", + "print(\"model weights\", nice_print_list(coeff))\n", + "print(\"model weights2\", nice_print_list(coeff2))\n", + "if created_ar_data: \n", + " plot_weights(\n", + " ar_val=len(ar_params[0]),\n", + " weights=coeff2[0],\n", + " ar=ar_params[0],\n", + " save=save,\n", + " savedir=results_path\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "fastai2_fork", + "language": "python", + "name": "fastai2_fork" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/v1_0/example_create_ar_data.ipynb b/v1_0/example_create_ar_data.ipynb new file mode 100644 index 0000000..18d0719 --- /dev/null +++ b/v1_0/example_create_ar_data.ipynb @@ -0,0 +1,152 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from statsmodels.tsa.arima_process import ArmaProcess" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from create_ar_data import generate_armaprocess_data\n", + "from create_ar_data import save_to_file, load_from_file" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "#### Notebook settings ####\n", + "random_ar_params = False\n", + "save = True\n", + "save_path = '../ar_data'" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "#### Data settings ####\n", + "# option 1: Randomly generated AR parameters\n", + "data_config_random = {\n", + " \"samples\": 10000,\n", + " \"noise_std\": 0.1,\n", + " \"ar_order\": 3,\n", + " \"ma_order\": 0,\n", + " \"params\": None, # for randomly generated AR params\n", + "}\n", + "\n", + "# option 2: Manually define AR parameters\n", + "data_config_manual = {\n", + " \"samples\": 10000,\n", + " \"noise_std\": 0.1,\n", + " \"params\": ([0.2, 0.3, -0.5], []), \n", + "# \"params\": ([0.2, 0, 0.3, 0, 0, 0, 0, 0, 0, -0.5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], []), \n", + "}\n", + "data_config_manual[\"ar_order\"] = int(sum(np.array(data_config_manual[\"params\"][0]) != 0.0))\n", + "data_config_manual[\"ma_order\"] = int(sum(np.array(data_config_manual[\"params\"][1]) != 0.0))" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'samples': 10000, 'noise_std': 0.1, 'params': ([0.2, 0.3, -0.5], []), 'ar_order': 3, 'ma_order': 0}\n" + ] + } + ], + "source": [ + "## Select config\n", + "data_config = data_config_random if random_ar_params else data_config_manual\n", + "print(data_config)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "## Generate data\n", + "series, data_config[\"ar_params\"], data_config[\"ma_params\"] = generate_armaprocess_data(**data_config)\n", + "del data_config[\"params\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loaded from saved files:\n", + "{'samples': 10000, 'noise_std': 0.1, 'ar_order': 3, 'ma_order': 0, 'ar_params': [0.2, 0.3, -0.5], 'ma_params': []}\n", + " 0\n", + "0 0.113264\n", + "1 0.071973\n", + "2 0.018946\n", + "3 0.125975\n", + "4 0.148541\n" + ] + } + ], + "source": [ + "if save:\n", + " data_name = save_to_file(save_path, series, data_config)\n", + " \n", + " # just to test:\n", + " df, data_config2 = load_from_file(save_path, data_name, load_config=True)\n", + " print(\"loaded from saved files:\")\n", + " print(data_config2)\n", + " print(df.head())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "fastai2", + "language": "python", + "name": "fastai2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/v1_0/example_make_dataset.ipynb b/v1_0/example_make_dataset.ipynb new file mode 100644 index 0000000..cedb627 --- /dev/null +++ b/v1_0/example_make_dataset.ipynb @@ -0,0 +1,281 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# import sktime\n", + "# https://alan-turing-institute.github.io/sktime/examples/forecasting.html\n", + "import os\n", + "import json\n", + "import pandas as pd\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from create_ar_data import load_from_file\n", + "from make_dataset import tabularize_univariate" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "## Notebook settings\n", + "data_path = '../ar_data'\n", + "data_name = 'ar_3_ma_0_noise_0.300_len_1253'" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "## Load data\n", + "## if created AR data with create_ar_data, we can use the helper function:\n", + "# df, data_config = load_from_file(data_path, data_name, load_config=True)\n", + "# print(data_config)\n", + "# n_lags = data_config[\"ar_order\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "## Load data\n", + "## else we can manually load any file that stores a time series, for example:\n", + "df = pd.read_csv(os.path.join(data_path, data_name + '.csv'), header=None, index_col=False)\n", + "n_lags = 3" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(1253, 1)\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
0
00.268074
10.089195
20.200403
3-0.159089
4-0.029965
\n", + "
" + ], + "text/plain": [ + " 0\n", + "0 0.268074\n", + "1 0.089195\n", + "2 0.200403\n", + "3 -0.159089\n", + "4 -0.029965" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(df.shape)\n", + "df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3\n" + ] + } + ], + "source": [ + "## create a tabularized dataset from time series\n", + "df_tab = tabularize_univariate(df, n_lags, n_forecasts=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(1250, 4)\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
x_0x_1x_2y_0
00.2680740.0891950.200403-0.159089
10.0891950.200403-0.159089-0.029965
20.200403-0.159089-0.0299650.592256
3-0.159089-0.0299650.5922560.368313
4-0.0299650.5922560.3683130.406311
\n", + "
" + ], + "text/plain": [ + " x_0 x_1 x_2 y_0\n", + "0 0.268074 0.089195 0.200403 -0.159089\n", + "1 0.089195 0.200403 -0.159089 -0.029965\n", + "2 0.200403 -0.159089 -0.029965 0.592256\n", + "3 -0.159089 -0.029965 0.592256 0.368313\n", + "4 -0.029965 0.592256 0.368313 0.406311" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(df_tab.shape)\n", + "df_tab.head()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "fastai2", + "language": "python", + "name": "fastai2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/v1_0/make_dataset.py b/v1_0/make_dataset.py new file mode 100644 index 0000000..1749eb2 --- /dev/null +++ b/v1_0/make_dataset.py @@ -0,0 +1,73 @@ +import pandas as pd + +from create_ar_data import load_from_file + + +def tabularize_univariate(series, n_lags, n_forecasts=1, nested_list=False): + """ + Create a tabular dataset with ar_order lags for supervised forecasting + Arguments: + series: Sequence of observations as a Pandas DataFrame + n_lags: Number of lag observations as input (X). + n_forecasts: Number of observations as output (y). + Returns: + df: Pandas DataFrame of input lags and forecast values (as nested lists) + shape (n_samples, 2). + Cols: "x": list(n_lags) + Cols: "y": list(n_forecasts) + """ + n_samples = len(series) - n_lags + 1 - n_forecasts + + x = pd.DataFrame([series.iloc[i: i + n_lags, 0].values + for i in range(n_samples)]) + y = pd.DataFrame([series.iloc[i + n_lags: i + n_lags + n_forecasts, 0].values + for i in range(n_samples)]) + if nested_list: + df = pd.concat([x.apply(list, axis=1), y.apply(list, axis=1)], axis=1) + df.columns = ["x", "y"] + else: + print(len(x.columns)) + df = pd.concat([x, y], axis=1) + df.columns = ["x_{}".format(num) for num in list(range(len(x.columns)))] + \ + ["y_{}".format(num) for num in list(range(len(y.columns)))] + return df + + +def main(): + verbose = True + data_path = 'ar_data' + data_name = 'ar_3_ma_0_noise_0.100_len_10000' + + ## if created AR data with create_ar_data, we can use the helper function: + df, data_config = load_from_file(data_path, data_name, load_config=True) + n_lags = data_config["ar_order"] + + ## else we can manually load any file that stores a time series, for example: + # df = pd.read_csv(os.path.join(data_path, data_name + '.csv'), header=None, index_col=False) + # n_lags = 3 + + if verbose: + print(data_config) + print(df.shape) + + ## create a tabularized dataset from time series + df_tab = tabularize_univariate( + df, + n_lags=n_lags, + n_forecasts=1, + nested_list=False, + ) + + if verbose: + print("tabularized df") + print(df_tab.shape) + # print(df_tab.columns) + # if nested_list: + # print("x_dim:", len(df_tab['x'][0]), "y_dim:", len(df_tab['y'][0])) + print(df_tab.head()) + + +if __name__ == '__main__': + main() + + diff --git a/v1_0/plotting.py b/v1_0/plotting.py new file mode 100644 index 0000000..e36e65c --- /dev/null +++ b/v1_0/plotting.py @@ -0,0 +1,53 @@ +import pandas as pd +import matplotlib.pyplot as plt +import seaborn as sns +import os + + +def plot_weights(ar_val, weights, ar, model_name="AR-Net", save=False, savedir="results"): + df = pd.DataFrame( + zip( + list(range(1, ar_val + 1)) * 2, + ["AR-Process (True)"] * ar_val + [model_name] * ar_val, + list(ar) + list(weights) + ), + columns=["AR-coefficient (lag number)", "model", "value (weight)"] + ) + plt.figure(figsize=(10, 6)) + palette = {"Classic-AR": "C0", "AR-Net": "C1", "AR-Process (True)": "k"} + sns.barplot(data=df, palette=palette, x="AR-coefficient (lag number)", hue="model", y="value (weight)") + # plt.show() + if save: + if not os.path.exists(savedir): + os.makedirs(savedir) + figname = 'weights_{}_{}.png'.format(ar_val, model_name) + plt.savefig(os.path.join(savedir, figname), dpi=600, bbox_inches='tight') + + +def plot_prediction_sample(predicted, actual, num_obs=100, model_name="AR-Net", save=False, savedir="results"): + fig2 = plt.figure() + fig2.set_size_inches(10, 6) + plt.plot(actual[0:num_obs]) + plt.plot(predicted[0:num_obs]) + plt.legend(["Actual Time-Series", "{}-Prediction".format(model_name)]) + if save: + if not os.path.exists(savedir): + os.makedirs(savedir) + figname = 'prediction_{}.png'.format(model_name) + plt.savefig(os.path.join(savedir, figname), dpi=600, bbox_inches='tight') + plt.show() + + +def plot_error_scatter(predicted, actual, model_name="AR-Net", save=False, savedir="results"): + # error = predicted - actual + fig3 = plt.figure() + fig3.set_size_inches(6, 6) + plt.scatter(actual, predicted - actual, marker='o', s=10, alpha=0.3) + plt.legend(["{}-Error".format(model_name)]) + if save: + if not os.path.exists(savedir): + os.makedirs(savedir) + figname = 'scatter_{}.png'.format(model_name) + plt.savefig(os.path.join(savedir, figname), dpi=600, bbox_inches='tight') + plt.show() + diff --git a/v1_0/utils.py b/v1_0/utils.py new file mode 100644 index 0000000..834d6b5 --- /dev/null +++ b/v1_0/utils.py @@ -0,0 +1,51 @@ +import numpy as np +import torch + + +def pad_ar_params(ar_params, n_lags, n_forecasts=1): + """" + pads ar_parameter lists to the length of n_lags + ar_params: list of length n_forecasts with elements: lists of ar coeffs + n_lags: length to which pad each of the ar coeffs + """ + assert n_forecasts == len(ar_params) + if n_forecasts != 1: + if all([isinstance(ar_params[i], list) for i in range(n_forecasts)]): + return [pad_ar_params([ar_params[i]], n_lags, 1)[0] for i in range(n_forecasts)] + else: raise NotImplementedError("AR Coeff for each of the forecast targets are needed") + return [ar_params[0] + [0.0]*(n_lags - len(ar_params[0]))] + + +def estimate_noise(series): + return float(np.mean(np.abs(series.iloc[:-1].values - series.iloc[1:].values))) + + +def split_by_p_valid(valid_p, n_sample, verbose=False): + split_idx = int(n_sample * (1 - valid_p)) + splits = [list(range(split_idx)), list(range(split_idx, n_sample))] + if verbose: + print("split on idx: ", split_idx) + print("split sizes: ", [len(x) for x in splits]) + return splits + + +def nice_print_list(data): + if all([isinstance(data[i], list) for i in range(len(data))]): + return [nice_print_list(data[i]) for i in range(len(data))] + return ["{:.3f}".format(x) for x in data] + # return [["{:.2f}".format(x) for x in sublist] for sublist in data] + + +def compute_sTPE(est, real): + est, real = np.array(est), np.array(real) + sum_abs_diff = np.sum(np.abs(est - real)) + sum_abs = np.sum(np.abs(est) + np.abs(real)) + return 100.0 * sum_abs_diff / (10e-9 + sum_abs) + + +def coeff_from_model(model, reversed_weights=True): + for layer in model.modules(): + if isinstance(layer, torch.nn.Linear): + weights = [list(x[::-1] if reversed_weights else x) + for x in layer.weight.detach().numpy()] + return weights # note: preliminary exit of loop is a feature.