diff --git a/experiments/azure-automl-forecasting/.env.example b/experiments/azure-automl-forecasting/.env.example new file mode 100644 index 00000000..0bfdf440 --- /dev/null +++ b/experiments/azure-automl-forecasting/.env.example @@ -0,0 +1,5 @@ +AZURE_SUBSCRIPTION_ID= +AZURE_RESOURCE_GROUP= +AZURE_WORKSPACE_NAME= +TIMEGPT_TOKEN= + diff --git a/experiments/azure-automl-forecasting/Makefile b/experiments/azure-automl-forecasting/Makefile new file mode 100644 index 00000000..406d6971 --- /dev/null +++ b/experiments/azure-automl-forecasting/Makefile @@ -0,0 +1,39 @@ +TS_FILES := Hourly_H.parquet Daily_D.parquet Weekly_W-MON.parquet Monthly_MS.parquet +FILTERED_TS_FILES := $(patsubst %,./data/filtered_datasets/%,$(TS_FILES)) + +filter_data: + @for file in $(TS_FILES); do \ + python -m src.utils.filter_data --dataset_path ./data/$$file; \ + done + +run_timegpt: .require-dataset_path + @echo Running TimeGPT with dataset_path=$(dataset_path) + @python -m src.nixtla_timegpt --dataset_path $(dataset_path) + +run_sn: .require-dataset_path + @echo Running SN with dataset_path=$(dataset_path) + @python -m src.statsforecast_sn --dataset_path $(dataset_path) + +run_automl: .require-dataset_path + @echo Running AutoML with dataset_path=$(dataset_path) + @python -m src.azure_automl.forecasting --dataset_path $(dataset_path) + +run_methods: + @for file in $(TS_FILES); do \ + echo "Running methods for $$file"; \ + $(MAKE) run_timegpt dataset_path=./data/filtered_datasets/$$file; \ + $(MAKE) run_sn dataset_path=./data/filtered_datasets/$$file; \ + $(MAKE) run_automl dataset_path=./data/$$file; \ + done + +download_automl_forecasts: + @python -m src.azure_automl.download_forecasts + +evaluate_experiments: + @python -m src.evaluation --datasets_paths "$(shell echo $(FILTERED_TS_FILES) | tr ' ' ',')" + +.require-dataset_path: +ifndef dataset_path + $(error dataset_path is required) +endif + diff --git a/experiments/azure-automl-forecasting/README.md b/experiments/azure-automl-forecasting/README.md new file mode 100644 index 00000000..2d4e673a --- /dev/null +++ b/experiments/azure-automl-forecasting/README.md @@ -0,0 +1,9 @@ +# Instructions + + +``` +mamba create -n azure-automl-fcst python=3.10 +conda activate azure-automl-fcst +pip install uv +uv pip install -r requirements.txt +``` diff --git a/experiments/azure-automl-forecasting/requirements.txt b/experiments/azure-automl-forecasting/requirements.txt new file mode 100644 index 00000000..56d9b64e --- /dev/null +++ b/experiments/azure-automl-forecasting/requirements.txt @@ -0,0 +1,11 @@ +azure-ai-ml +azure-identity +azureml-core +fire +mltable +nixtlats +pandas +python-dotenv +rich +statsforecast +utilsforecast diff --git a/experiments/azure-automl-forecasting/src/azure_automl/__init__.py b/experiments/azure-automl-forecasting/src/azure_automl/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/experiments/azure-automl-forecasting/src/azure_automl/automl_handler.py b/experiments/azure-automl-forecasting/src/azure_automl/automl_handler.py new file mode 100644 index 00000000..bdd7116f --- /dev/null +++ b/experiments/azure-automl-forecasting/src/azure_automl/automl_handler.py @@ -0,0 +1,253 @@ +import json +import logging +import os +import yaml +from tempfile import TemporaryDirectory +from pathlib import Path + +import numpy as np +import pandas as pd +from azure.ai.ml import Input +from azure.ai.ml import MLClient +from azure.ai.ml.constants import AssetTypes +from azure.ai.ml.dsl import pipeline +from azure.ai.ml.entities import AmlCompute, Job +from azure.identity import DefaultAzureCredential +from dotenv import load_dotenv + +load_dotenv() +logging.basicConfig(level=logging.INFO) +main_logger = logging.getLogger(__name__) + +loggers = logging.Logger.manager.loggerDict +for logger_name in loggers: + if logger_name.startswith("azure"): + logger = logging.getLogger(logger_name) + logger.disabled = True + logger.propagate = False + + +def str_to_datetime(date_str: str) -> pd.Timestamp: + return pd.Timestamp(date_str) + + +def df_to_parquet_azureml_input(df: pd.DataFrame, dir: str) -> Input: + series_path = Path(dir) / "series.parquet" + df.to_parquet(series_path, index=False) + table_data_input = Input(type=AssetTypes.URI_FOLDER, path=dir) + return table_data_input + + +def config_to_yaml_azureml_input(config: dict, dir: str) -> Input: + config_path = Path(dir) / "config.yaml" + with open(config_path, "w") as f: + yaml.dump(config, f) + config = Input(type="uri_file", path=str(config_path)) + return config + + +class AzureAutoML: + """ + Before using this class, you need to login to Azure. + Use the following command to login: + $ az login + """ + + def __init__( + self, + subscription_id: str, + resource_group_name: str, + workspace_name: str, + ): + self.subscription_id = subscription_id + self.resource_group_name = resource_group_name + self.workspace_name = workspace_name + + @classmethod + def from_environment(cls) -> "AzureAutoML": + return cls( + subscription_id=os.environ["AZURE_SUBSCRIPTION_ID"], + resource_group_name=os.environ["AZURE_RESOURCE_GROUP"], + workspace_name=os.environ["AZURE_WORKSPACE_NAME"], + ) + + def get_ml_client(self, registry_name: str | None = None) -> MLClient: + kwargs = {} + if not registry_name: + kwargs["workspace_name"] = self.workspace_name + else: + kwargs["registry_name"] = registry_name + credential = DefaultAzureCredential(exclude_managed_identity_credential=True) + ml_client = MLClient( + credential=credential, + subscription_id=self.subscription_id, + resource_group_name=self.resource_group_name, + **kwargs, + ) + return ml_client + + def get_train_and_inference_components(self) -> tuple: + ml_client_reqistry = self.get_ml_client("azureml") + train_component = ml_client_reqistry.components.get( + name="automl_many_models_training", + label="latest", + ) + inference_component = ml_client_reqistry.components.get( + name="automl_many_models_inference", + label="latest", + ) + return train_component, inference_component + + def forecast( + self, + df: pd.DataFrame, + df_test: pd.DataFrame, + aml_compute: AmlCompute, + h: int, + freq: str, + id_col: str = "unique_id", + time_col: str = "ds", + target_col: str = "y", + primary_metric: str = "normalized_root_mean_squared_error", + n_cross_validations: str | int = "auto", + experiment_name: str | None = None, + begin_create_or_update_aml_compute: bool = False, + max_trials: int = 25, + enable_early_stopping: bool = True, + max_nodes: int = 1, + max_concurrency_per_node: int = 1, + forecast_mode: str = "rolling", + retrain_failed_model: bool = False, + ) -> str: + if experiment_name is None: + random_id = np.random.randint(10000, 99999) + experiment_name = f"automl-forecasting-job-{random_id}" + ml_client = self.get_ml_client() + train_component, inference_component = self.get_train_and_inference_components() + automl_config_dict = dict( + task="forecasting", + forecast_horizon=h, + forecast_step=h, + frequency=freq, + time_series_id_column_names=id_col, + partition_column_names=[id_col], + time_column_name=time_col, + label_column_name=target_col, + primary_metric=primary_metric, + n_cross_validations=n_cross_validations, + max_trials=max_trials, + enable_early_stopping=enable_early_stopping, + track_child_runs=False, + allow_multi_partitions=False, + # allowed_training_algorithms=["Naive"], + ) + + @pipeline(description="pipeline for automl forecasting") + def forecasting_pipeline( + training_data: Input, + test_data: Input, + automl_config: Input, + compute_name: str, + ): + # training node + training_node = train_component( + raw_data=training_data, + automl_config=automl_config, + max_concurrency_per_node=max_concurrency_per_node, + max_nodes=max_nodes, + retrain_failed_model=retrain_failed_model, + compute_name=compute_name, + ) + # inference node + inference_node = inference_component( + raw_data=test_data, + max_nodes=max_nodes, + max_concurrency_per_node=max_concurrency_per_node, + optional_train_metadata=training_node.outputs.run_output, + forecast_mode=forecast_mode, + forecast_step=h, + compute_name=compute_name, + ) + return {"forecast_output": inference_node.outputs.raw_predictions} + + if begin_create_or_update_aml_compute: + main_logger.info("Begin create or update aml compute") + ml_client.compute.begin_create_or_update(aml_compute).result() + + cwd = Path.cwd() + with TemporaryDirectory(dir=cwd) as tmp_dir, TemporaryDirectory( + dir=cwd + ) as tmp_dir_test, TemporaryDirectory(dir=cwd) as tmp_dir_config: + main_logger.info("Transforming datasets to parquet") + table_data_input = df_to_parquet_azureml_input(df, dir=tmp_dir) + table_data_input_test = df_to_parquet_azureml_input( + df_test, + dir=tmp_dir_test, + ) + automl_config = config_to_yaml_azureml_input( + automl_config_dict, + dir=tmp_dir_config, + ) + pipeline_job = forecasting_pipeline( + training_data=table_data_input, + test_data=table_data_input_test, + automl_config=automl_config, + compute_name=aml_compute.name, + ) + pipeline_job.settings.default_compute = aml_compute.name + main_logger.info("Begin submitting pipeline job") + returned_pipeline_job = ml_client.jobs.create_or_update( + pipeline_job, + experiment_name=experiment_name, + ) + return returned_pipeline_job.name + + def get_job(self, job_name: str) -> Job: + ml_client = self.get_ml_client() + job = ml_client.jobs.get(job_name) + return job + + def get_job_status(self, job_name: str) -> str | None: + job = self.get_job(job_name) + return job.status + + def get_job_total_time(self, job_name: str) -> float | None: + job = self.get_job(job_name) + if job.status == "NotStarted": + main_logger.info(f"Job {job_name} is not started yet") + return None + stages_key = "azureml.pipelines.stages" + if stages_key not in job.properties: + main_logger.info(f"Job {job_name} has no stages yet") + return None + stages = json.loads(job.properties[stages_key]) + execution_info = stages["Execution"] + status = execution_info["Status"] + if status == "Failed": + raise Exception(f"Job {job_name} failed") + start_time = str_to_datetime(execution_info["StartTime"]) + if "EndTime" not in execution_info: + total_time = pd.Timestamp.now(tz=start_time.tz) - start_time + main_logger.info( + f"Job has status {status}, total time so far: {total_time.total_seconds()}" + ) + end_time = str_to_datetime(execution_info["EndTime"]) + total_time = end_time - start_time + return total_time.total_seconds() + + def get_forecast_df(self, job_name: str) -> pd.DataFrame | None: + job_status = self.get_job_status(job_name) + if job_status != "Completed": + main_logger.info(f"Job {job_name} is not completed yet") + return None + ml_client = self.get_ml_client() + cwd = Path.cwd() + with TemporaryDirectory(dir=cwd) as tmp_dir: + ml_client.jobs.download( + job_name, + download_path=tmp_dir, + output_name="forecast_output", + ) + output_path = Path(tmp_dir) / "named-outputs" / "forecast_output" + forecast_df = pd.read_parquet(output_path) + return forecast_df diff --git a/experiments/azure-automl-forecasting/src/azure_automl/download_forecasts.py b/experiments/azure-automl-forecasting/src/azure_automl/download_forecasts.py new file mode 100644 index 00000000..65208d8f --- /dev/null +++ b/experiments/azure-automl-forecasting/src/azure_automl/download_forecasts.py @@ -0,0 +1,53 @@ +import logging +from pathlib import Path + +import fire + +from .automl_handler import AzureAutoML +from .forecasting import AzureAutoMLJobs +from src.utils.data_handler import ForecastDataset + +logging.basicConfig(level=logging.INFO) +main_logger = logging.getLogger(__name__) + + +def download_forecasts(dir: str = "./results"): + azure_automl = AzureAutoML.from_environment() + azure_automl_experiments = AzureAutoMLJobs() + results_path = Path(dir) / "azure_automl" + + jobs_df = azure_automl_experiments.get_jobs_df() + jobs_df = jobs_df.sort_values("created_at", ascending=False).drop_duplicates( + "experiment_name" + ) + + for _, row in jobs_df.iterrows(): + experiment_name = row.experiment_name + job_name = row.job_name + main_logger.info( + f"Downloading forecasts for experiment {experiment_name} and job {job_name}" + ) + try: + forecast_df = azure_automl.get_forecast_df(job_name) + total_time = azure_automl.get_job_total_time(job_name) + except Exception: + main_logger.info( + f"Failed to download forecasts for experiment {experiment_name} and job {job_name}" + ) + continue + if forecast_df is None: + main_logger.info( + f"Failed to download forecasts for experiment {experiment_name} and job {job_name}" + "probably because the job is not finished yet or failed" + ) + continue + fcst_dataset = ForecastDataset(forecast_df=forecast_df, total_time=total_time) + experiment_name = row.experiment_name + fcst_dataset.save_to_dir(results_path / experiment_name) + main_logger.info( + f"Saved forecasts for experiment {experiment_name} and job {job_name}" + ) + + +if __name__ == "__main__": + fire.Fire(download_forecasts) diff --git a/experiments/azure-automl-forecasting/src/azure_automl/forecasting.py b/experiments/azure-automl-forecasting/src/azure_automl/forecasting.py new file mode 100644 index 00000000..dd10896f --- /dev/null +++ b/experiments/azure-automl-forecasting/src/azure_automl/forecasting.py @@ -0,0 +1,90 @@ +from pathlib import Path + +import fire +import pandas as pd +from azure.ai.ml.entities import AmlCompute + +from .automl_handler import AzureAutoML +from src.utils.data_handler import ExperimentDataset + + +class AzureAutoMLJobs: + """ + This class stores and updates the Azure AutoML Experiments, + to keep track of the pipeline jobs. + We need this to later downlaod the forecasts. + """ + + file_name = "forecasting_jobs.csv" + + def __init__(self, dir: str = "./azure_automl_results"): + self.dir = dir + self.jobs_path = Path(self.dir) / self.file_name + self.setup() + + def setup(self): + self.jobs_path.parent.mkdir(parents=True, exist_ok=True) + if not self.jobs_path.exists(): + pd.DataFrame(columns=["created_at", "experiment_name", "job_name"]).to_csv( + self.jobs_path, + index=False, + ) + + def get_jobs_df(self) -> pd.DataFrame: + return pd.read_csv(self.jobs_path) + + def save_job(self, job_name: str, experiment_name: str): + jobs_df = self.get_jobs_df() + new_row = pd.DataFrame( + { + "created_at": [pd.Timestamp.now()], + "experiment_name": [experiment_name], + "job_name": [job_name], + } + ) + jobs_df = pd.concat([jobs_df, new_row]) + jobs_df.to_csv(self.jobs_path, index=False) + + +def start_forecasting_job( + dataset_path: str, + begin_create_or_update_aml_compute: bool = False, +): + # for Daily_D and Weekly_W-MON we restrcit the max_insample_length + # to prevent the cluster for breaking + experiment_name = dataset_path.split("/")[-1].split(".")[0] + kwargs = dict() + if experiment_name in ["Daily_D", "Weekly_W-MON"]: + kwargs["max_insample_length"] = 100 + dataset = ExperimentDataset.from_parquet( + parquet_path=dataset_path, + **kwargs, + ) + azure_automl = AzureAutoML.from_environment() + azure_automl_jobs = AzureAutoMLJobs() + + aml_compute = AmlCompute( + name="azure-automl-fcst-cluster-nixtla", + min_instances=11, + max_instances=11, + size="STANDARD_DS5_V2", + ) + + job_name = azure_automl.forecast( + df=dataset.Y_df_train, + df_test=dataset.Y_df_test, + aml_compute=aml_compute, + h=dataset.horizon, + freq=dataset.pandas_frequency, + n_cross_validations=2, + experiment_name=experiment_name, + begin_create_or_update_aml_compute=begin_create_or_update_aml_compute, + max_nodes=11, + max_concurrency_per_node=8, + ) + + azure_automl_jobs.save_job(job_name, experiment_name) + + +if __name__ == "__main__": + fire.Fire(start_forecasting_job) diff --git a/experiments/azure-automl-forecasting/src/evaluation.py b/experiments/azure-automl-forecasting/src/evaluation.py new file mode 100644 index 00000000..6d7cd16d --- /dev/null +++ b/experiments/azure-automl-forecasting/src/evaluation.py @@ -0,0 +1,137 @@ +import logging +from pathlib import Path +from typing import List +from unicodedata import numeric + +import fire +import pandas as pd +from rich.console import Console +from rich.table import Table + +from src.utils.data_handler import ExperimentDataset, ForecastDataset + +logging.basicConfig(level=logging.INFO) +main_logger = logging.getLogger(__name__) + + +def print_df_rich(df: pd.DataFrame): + console = Console() + table = Table() + for col in df.select_dtypes(include=["float"]).columns: + df[col] = df[col].apply(lambda x: f"{x:.3f}") + for col in df.columns: + table.add_column(col) + for row in df.itertuples(index=False): + table.add_row(*row) + console.print(table) + + +METHODS = { + "azure_automl": "automl_prediction", + "nixtla_timegpt": "TimeGPT", + "statsforecast_sn": "SeasonalNaive", +} + + +def get_model_name(method: str) -> str: + if method not in METHODS: + raise ValueError(f"Invalid method: {method}") + return METHODS[method] + + +def evaluate_experiments( + datasets_paths: str, + methods_to_evaluate: List[str] = list(METHODS.keys()), + results_dir: str = "./results", +): + datasets_paths_ = datasets_paths.split(",") + eval_datasets_df: pd.DataFrame | None = None + for dataset_path in datasets_paths_: + experiment_name = dataset_path.split("/")[-1].split(".")[0] + eval_method_df: pd.DataFrame | None = None + dataset: None | ExperimentDataset = None + for method in methods_to_evaluate: + results_experiment_dir = Path(results_dir) / method / experiment_name + if ForecastDataset.is_forecast_ready(results_experiment_dir): + main_logger.info( + f"Evaluating experiment {experiment_name} and method {method}" + ) + forecast_dataset = ForecastDataset.from_dir(results_experiment_dir) + if dataset is None: + dataset = ExperimentDataset.from_parquet(parquet_path=dataset_path) + eval_df = dataset.evaluate_forecast_df( + forecast_df=forecast_dataset.forecast_df, + model=get_model_name(method), + total_time=forecast_dataset.total_time, + ) + if eval_method_df is None: + eval_method_df = eval_df + else: + eval_method_df = pd.concat( + [eval_method_df, eval_df], + axis=1, + ) # type: ignore + else: + main_logger.info( + f"Skipping evaluation for experiment {experiment_name} and method {method}" + " because the forecasts are not ready yet" + ) + if eval_method_df is not None: + eval_method_df.reset_index(inplace=True) + eval_method_df.insert(0, "dataset", experiment_name) + if eval_datasets_df is None: + eval_datasets_df = eval_method_df + else: + eval_datasets_df = pd.concat( + [eval_datasets_df, eval_method_df], + ignore_index=True, + ) # type: ignore + if eval_datasets_df is not None: + azure_renamer = {"automl_prediction": "AzureAutoML"} + if "azure_automl" in methods_to_evaluate: + eval_datasets_df = eval_datasets_df.rename(columns=azure_renamer) + eval_datasets_df.to_csv(Path(results_dir) / "eval_datasets.csv", index=False) + eval_datasets_df["metric"] = ( + eval_datasets_df["metric"].str.upper().str.replace("TOTAL_", "") + ) + # scale by SeasonalNaive + if "SeasonalNaive" in eval_datasets_df.columns: + time_mask = eval_datasets_df["metric"] == "TIME" + for model in eval_datasets_df.columns.drop(["dataset", "metric"]): + if model == "SeasonalNaive": + continue + eval_datasets_df.loc[~time_mask, model] = ( + eval_datasets_df.loc[~time_mask, model] + / eval_datasets_df.loc[~time_mask, "SeasonalNaive"] + ) + eval_datasets_df = eval_datasets_df.drop(columns=["SeasonalNaive"]) + + def pivot_df(df: pd.DataFrame, col: str) -> pd.DataFrame: + return df.pivot( + index="dataset", + columns="metric", + values=col, + ) + + result_list = [] + models = [] + for method in methods_to_evaluate: + if method == "statsforecast_sn": + continue + if method == "azure_automl": + col = "AzureAutoML" + else: + col = get_model_name(method) + pivotted_df = pivot_df(eval_datasets_df, col) + result_list.append(pivotted_df) + models.append(col) + result = pd.concat(result_list, axis=1, keys=models) + result = result.swaplevel(axis=1).sort_index(axis=1) + flattened_columns = ["_".join(col) for col in result.columns.values] + result.columns = flattened_columns + result = result.reset_index() + print_df_rich(result) + + +if __name__ == "__main__": + fire.Fire(evaluate_experiments) diff --git a/experiments/azure-automl-forecasting/src/nixtla_timegpt.py b/experiments/azure-automl-forecasting/src/nixtla_timegpt.py new file mode 100644 index 00000000..c90dfb28 --- /dev/null +++ b/experiments/azure-automl-forecasting/src/nixtla_timegpt.py @@ -0,0 +1,35 @@ +from pathlib import Path +from time import time + +import fire +from dotenv import load_dotenv +from nixtlats import TimeGPT + +from src.utils.data_handler import ExperimentDataset, ForecastDataset + +load_dotenv() + + +def timegpt_forecast(dataset_path: str, results_dir: str = "./results"): + dataset = ExperimentDataset.from_parquet(parquet_path=dataset_path) + timegpt = TimeGPT(max_retries=1) + start = time() + forecast_df = timegpt.forecast( + df=dataset.Y_df_train, + h=dataset.horizon, + freq=dataset.pandas_frequency, + model="timegpt-1-long-horizon", + ) + end = time() + total_time = end - start + forecast_dataset = ForecastDataset( + forecast_df=forecast_df, + total_time=total_time, + ) + experiment_name = dataset_path.split("/")[-1].split(".")[0] + results_path = Path(results_dir) / "nixtla_timegpt" / experiment_name + forecast_dataset.save_to_dir(results_path) + + +if __name__ == "__main__": + fire.Fire(timegpt_forecast) diff --git a/experiments/azure-automl-forecasting/src/statsforecast_sn.py b/experiments/azure-automl-forecasting/src/statsforecast_sn.py new file mode 100644 index 00000000..a641715a --- /dev/null +++ b/experiments/azure-automl-forecasting/src/statsforecast_sn.py @@ -0,0 +1,33 @@ +import os +from pathlib import Path +from time import time + +import fire +from statsforecast import StatsForecast +from statsforecast.models import SeasonalNaive + +from src.utils.data_handler import ExperimentDataset, ForecastDataset + + +def sn_forecast(dataset_path: str, results_dir: str = "./results"): + os.environ["NIXTLA_ID_AS_COL"] = "true" + dataset = ExperimentDataset.from_parquet(parquet_path=dataset_path) + sf = StatsForecast( + models=[SeasonalNaive(season_length=dataset.seasonality)], + freq=dataset.pandas_frequency, + ) + start = time() + forecast_df = sf.forecast( + df=dataset.Y_df_train, + h=dataset.horizon, + ) + end = time() + total_time = end - start + forecast_dataset = ForecastDataset(forecast_df=forecast_df, total_time=total_time) + experiment_name = dataset_path.split("/")[-1].split(".")[0] + results_path = Path(results_dir) / "statsforecast_sn" / experiment_name + forecast_dataset.save_to_dir(results_path) + + +if __name__ == "__main__": + fire.Fire(sn_forecast) diff --git a/experiments/azure-automl-forecasting/src/utils/data_handler.py b/experiments/azure-automl-forecasting/src/utils/data_handler.py new file mode 100644 index 00000000..c14b5b07 --- /dev/null +++ b/experiments/azure-automl-forecasting/src/utils/data_handler.py @@ -0,0 +1,135 @@ +import logging +import warnings +from dataclasses import dataclass, asdict +from functools import partial +from pathlib import Path + +import pandas as pd +from utilsforecast.evaluation import evaluate +from utilsforecast.losses import rmse, mae, mase + +from src.utils.filter_data import DatasetParams + +warnings.simplefilter(action="ignore", category=FutureWarning) +logging.basicConfig(level=logging.INFO) +main_logger = logging.getLogger(__name__) + + +@dataclass +class ExperimentDataset: + Y_df_train: pd.DataFrame + Y_df_test: pd.DataFrame + horizon: int + seasonality: int + frequency: str + pandas_frequency: str + + @classmethod + def from_df(cls, df: pd.DataFrame) -> "ExperimentDataset": + """ + Parameters + ---------- + df : pd.DataFrame + df should have columns: unique_id, ds, y, frequency, pandas_frequency, horizon, seasonality + """ + ds_params = DatasetParams.from_df(df) + df = df[["unique_id", "ds", "y"]] # type: ignore + Y_df_test = df.groupby("unique_id").tail(ds_params.horizon) + Y_df_train = df.drop(Y_df_test.index) # type: ignore + return cls( + Y_df_train=Y_df_train, + Y_df_test=Y_df_test, + **asdict(ds_params), + ) + + @classmethod + def from_parquet( + cls, + parquet_path: str, + ) -> "ExperimentDataset": + df = pd.read_parquet(parquet_path) + return cls.from_df(df=df) + + def evaluate_forecast_df( + self, + forecast_df: pd.DataFrame, + model: str, + total_time: float, + ) -> pd.DataFrame: + df_ = self.Y_df_test.copy(deep=True) + if forecast_df.dtypes["ds"] != df_.dtypes["ds"]: + df_["ds"] = df_["ds"].astype(forecast_df.dtypes["ds"]) + df = df_.merge( + forecast_df[["unique_id", "ds", model]], + on=["unique_id", "ds"], + how="left", + ) + if df[model].isna().sum() > 0: + na_uids = df.loc[df[model].isna()]["unique_id"].unique() + main_logger.warning( + f"{model} contains NaN for {len(na_uids)} series: {na_uids}" + "filling with last values" + ) + from statsforecast import StatsForecast + from statsforecast.models import SeasonalNaive + + sf = StatsForecast( + models=[SeasonalNaive(season_length=self.seasonality)], + freq=self.pandas_frequency, + ) + sn_df = sf.forecast( + df=self.Y_df_train, + h=self.horizon, + ) + df = df.merge(sn_df, on=["unique_id", "ds"], how="left") # type: ignore + df.loc[df["unique_id"].isin(na_uids), model] = df.loc[ + df["unique_id"].isin(na_uids), "SeasonalNaive" + ] + df = df.drop(columns=["SeasonalNaive"]) + partial_mase = partial(mase, seasonality=self.seasonality) + eval_df = evaluate( + df=df, + metrics=[rmse, mae, partial_mase], + train_df=self.Y_df_train, + models=[model], + ) + eval_df = eval_df.groupby("metric").mean(numeric_only=True).reset_index() # type: ignore + eval_time_df = pd.DataFrame( + { + "metric": ["total_time"], + model: [total_time], + } + ) + eval_df = pd.concat( + [eval_df, eval_time_df], + ignore_index=True, + ) # type: ignore + return eval_df.set_index("metric") + + +@dataclass +class ForecastDataset: + forecast_df: pd.DataFrame + total_time: float + + @classmethod + def from_dir(cls, dir: str | Path): + dir_ = Path(dir) + forecast_df = pd.read_parquet(dir_ / "forecast_df.parquet") + with open(dir_ / "total_time.txt", "r") as file: + total_time = float(file.read()) + return cls(forecast_df=forecast_df, total_time=total_time) + + @staticmethod + def is_forecast_ready(dir: str | Path): + dir_ = Path(dir) + forecast_path = dir_ / "forecast_df.parquet" + time_path = dir_ / "total_time.txt" + return forecast_path.exists() and time_path.exists() + + def save_to_dir(self, dir: str | Path): + dir_ = Path(dir) + dir_.mkdir(parents=True, exist_ok=True) + self.forecast_df.to_parquet(dir_ / "forecast_df.parquet") + with open(dir_ / "total_time.txt", "w") as file: + file.write(str(self.total_time)) diff --git a/experiments/azure-automl-forecasting/src/utils/download_data.py b/experiments/azure-automl-forecasting/src/utils/download_data.py new file mode 100644 index 00000000..c851219e --- /dev/null +++ b/experiments/azure-automl-forecasting/src/utils/download_data.py @@ -0,0 +1,64 @@ +import logging +from concurrent.futures import ProcessPoolExecutor + +import pandas as pd + +logging.basicConfig(level=logging.INFO) +main_logger = logging.getLogger(__name__) + + +def read_parquet_and_assign(uid, url): + df = pd.read_parquet(url) + df["unique_id"] = uid + df["ds"] = df["ds"].astype(str) + return df[["unique_id", "ds", "y"]] + + +def download_data(): + catalogue_splits = pd.read_parquet("./data/catalogue_splits.parquet") + catalogue_datasets = pd.read_parquet("./data/catalogue_datasets.parquet") + catalogue_df = catalogue_splits.merge( + catalogue_datasets, + on=["dataset", "subdataset", "frequency"], + ) + del catalogue_splits + del catalogue_datasets + catalogue_df = catalogue_df.query("split == 'test'")[ + [ + "unique_id", + "frequency", + "url", + "pandas_frequency", + "seasonality", + "horizon", + ] + ] + grouped_df = catalogue_df.groupby(["frequency", "pandas_frequency"]) + for (frequency, pandas_frequency), df in grouped_df: + uids, urls = df["unique_id"].values, df["url"].values + main_logger.info( + f"frequency: {frequency}, pandas_frequency: {pandas_frequency}" + ) + n_uids = len(uids) + main_logger.info(f"number of uids: {n_uids}") + max_workers = min(10, n_uids) + with ProcessPoolExecutor(max_workers=max_workers) as executor: + futures = [ + executor.submit(read_parquet_and_assign, uid, url) + for uid, url in zip(uids, urls) + ] + results = [future.result() for future in futures] + main_logger.info("dataset read") + Y_df = pd.concat(results) + Y_df = Y_df.merge( + df.drop(columns="url"), + on="unique_id", + how="left", + ) + Y_df.to_parquet(f"./data/{frequency}_{pandas_frequency}.parquet") + del Y_df + main_logger.info("dataset saved") + + +if __name__ == "__main__": + download_data() diff --git a/experiments/azure-automl-forecasting/src/utils/filter_data.py b/experiments/azure-automl-forecasting/src/utils/filter_data.py new file mode 100644 index 00000000..58d176be --- /dev/null +++ b/experiments/azure-automl-forecasting/src/utils/filter_data.py @@ -0,0 +1,104 @@ +""" +this module takes Nixtla's benchmarking data +and filters it to prevent azureml from crashing +in the following cases: +- too short series, see https://learn.microsoft.com/en-us/azure/machine-learning/concept-automl-forecasting-methods?view=azureml-api-2#data-length-requirements +""" +import logging +from dataclasses import dataclass +from pathlib import Path +from typing import Any, Callable + +import fire +import numpy as np +import pandas as pd + +logging.basicConfig(level=logging.INFO) +main_logger = logging.getLogger(__name__) + + +@dataclass +class DatasetParams: + frequency: str + pandas_frequency: str + horizon: int + seasonality: int + + @staticmethod + def _get_value_from_df_col( + df: pd.DataFrame, + col: str, + dtype: Callable | None = None, + ) -> Any: + col_values = df[col].unique() + if len(col_values) > 1: + raise ValueError(f"{col} is not unique: {col_values}") + value = col_values[0] + if dtype is not None: + value = dtype(value) + return value + + @classmethod + def from_df(cls, df: pd.DataFrame) -> "DatasetParams": + dataset_params = {} + dataset_params_cols = [ + "frequency", + "pandas_frequency", + "horizon", + "seasonality", + ] + dataset_params_cols_dtypes = [str, str, int, int] + for col, dtype in zip(dataset_params_cols, dataset_params_cols_dtypes): + dataset_params[col] = cls._get_value_from_df_col(df, col, dtype=dtype) + return cls(**dataset_params) + + +def filter_and_clean_dataset( + dataset_path: str, + max_series: int = 1_000, + n_train_cv: int = 2, + n_seasonalities: int = 5, + max_insample_length: int = 3_000, + random_seed: int = 420, +): + main_logger.info(f"Processing dataset {dataset_path}") + df = pd.read_parquet(dataset_path) + df = df.drop_duplicates(["unique_id", "ds"]) # type: ignore + df = df.sort_values(["unique_id", "ds"]) + ds_params = DatasetParams.from_df(df) + min_train_size_per_series = ( + ds_params.horizon + + 2 * ds_params.horizon + + (n_train_cv - 1) * ds_params.horizon + + 1 + ) + if ds_params.seasonality < 100: + # if series has low seasonality + # we add n_seasonalities to min_train_size_per_series + # to keep the series long enough + min_train_size_per_series += n_seasonalities * ds_params.seasonality + df = ( + df.groupby("unique_id") + .filter(lambda x: len(x) >= min_train_size_per_series) + .tail(max_insample_length + ds_params.horizon) + .reset_index(drop=True) + ) + uids = df["unique_id"].unique() # type: ignore + if len(uids) > max_series: + np.random.seed(random_seed) + uids = np.random.choice(uids, max_series, replace=False) # type: ignore + df = df.query("unique_id in @uids") # type: ignore + main_logger.info(f"Filtering out {len(uids) - max_series} series") + # finally we clean some strange dates + mask = df["ds"].str.endswith(":01") # type: ignore + df.loc[mask, "ds"] = df.loc[mask, "ds"].str[:-3] + ":00" + # save the dataset + dataset_path = Path(dataset_path) # type: ignore + filtered_dataset_path = dataset_path.parent / "filtered_datasets" / dataset_path.name # type: ignore + filtered_dataset_path.parent.mkdir(exist_ok=True, parents=True) + df.to_parquet(filtered_dataset_path) + main_logger.info(f"Filtered dataset saved to {filtered_dataset_path}") + + +if __name__ == "__main__": + fire.Fire(filter_and_clean_dataset) diff --git a/nbs/distributed.timegpt.ipynb b/nbs/distributed.timegpt.ipynb index 87e51901..3123d4a2 100644 --- a/nbs/distributed.timegpt.ipynb +++ b/nbs/distributed.timegpt.ipynb @@ -160,6 +160,7 @@ " target_col: str = 'y',\n", " X_df: Optional[fugue.AnyDataFrame] = None,\n", " level: Optional[List[Union[int, float]]] = None,\n", + " quantiles: Optional[List[float]] = None,\n", " finetune_steps: int = 0,\n", " finetune_loss: str = 'default',\n", " clean_ex_first: bool = True,\n", @@ -177,6 +178,7 @@ " time_col=time_col,\n", " target_col=target_col,\n", " level=level,\n", + " quantiles=quantiles,\n", " finetune_steps=finetune_steps,\n", " finetune_loss=finetune_loss,\n", " clean_ex_first=clean_ex_first,\n", @@ -186,7 +188,12 @@ " date_features_to_one_hot=date_features_to_one_hot,\n", " model=model,\n", " )\n", - " schema = self._get_forecast_schema(id_col=id_col, time_col=time_col, level=level)\n", + " schema = self._get_forecast_schema(\n", + " id_col=id_col, \n", + " time_col=time_col, \n", + " level=level,\n", + " quantiles=quantiles,\n", + " )\n", " fcst_df = self._distribute_method(\n", " method=self._forecast if X_df is None else self._forecast_x,\n", " df=df,\n", @@ -246,6 +253,7 @@ " time_col: str = 'ds',\n", " target_col: str = 'y',\n", " level: Optional[List[Union[int, float]]] = None,\n", + " quantiles: Optional[List[float]] = None,\n", " finetune_steps: int = 0,\n", " finetune_loss: str = 'default',\n", " clean_ex_first: bool = True,\n", @@ -264,6 +272,7 @@ " time_col=time_col,\n", " target_col=target_col,\n", " level=level,\n", + " quantiles=quantiles,\n", " finetune_steps=finetune_steps,\n", " finetune_loss=finetune_loss,\n", " clean_ex_first=clean_ex_first,\n", @@ -274,7 +283,13 @@ " n_windows=n_windows,\n", " step_size=step_size,\n", " )\n", - " schema = self._get_forecast_schema(id_col=id_col, time_col=time_col, level=level, cv=True)\n", + " schema = self._get_forecast_schema(\n", + " id_col=id_col, \n", + " time_col=time_col, \n", + " level=level,\n", + " quantiles=quantiles,\n", + " cv=True,\n", + " )\n", " fcst_df = self._distribute_method(\n", " method=self._cross_validation,\n", " df=df,\n", @@ -330,15 +345,23 @@ " return timegpt._cross_validation(df=df, **kwargs)\n", " \n", " @staticmethod\n", - " def _get_forecast_schema(id_col, time_col, level, cv=False):\n", + " def _get_forecast_schema(id_col, time_col, level, quantiles, cv=False):\n", " schema = f'{id_col}:string,{time_col}:datetime'\n", " if cv:\n", " schema = f'{schema},cutoff:datetime'\n", " schema = f'{schema},TimeGPT:double'\n", + " if (level is not None) and (quantiles is not None):\n", + " raise Exception(\n", + " \"you should include `level` or `quantiles` but not both.\"\n", + " )\n", " if level is not None:\n", " level = sorted(level)\n", " schema = f'{schema},{\",\".join([f\"TimeGPT-lo-{lv}:double\" for lv in reversed(level)])}'\n", " schema = f'{schema},{\",\".join([f\"TimeGPT-hi-{lv}:double\" for lv in level])}'\n", + " if quantiles is not None:\n", + " quantiles = sorted(quantiles)\n", + " q_cols = [f'TimeGPT-q-{int(q * 100)}:double' for q in quantiles]\n", + " schema = f'{schema},{\",\".join(q_cols)}'\n", " return Schema(schema)\n", " \n", " @staticmethod\n", @@ -798,6 +821,34 @@ " #test_anomalies_same_results_num_partitions(df, id_col=id_col, time_col=time_col, date_features=True, clean_ex_first=False)" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#| hide\n", + "def test_quantiles(df: fugue.AnyDataFrame, id_col: str = 'id_col', time_col: str = 'time_col'):\n", + " test_qls = list(np.arange(0.1, 1, 0.1))\n", + " exp_q_cols = [f\"TimeGPT-q-{int(q * 100)}\" for q in test_qls]\n", + " def test_method_qls(method, **kwargs):\n", + " df_qls = method(\n", + " df=df, \n", + " h=12, \n", + " id_col=id_col,\n", + " time_col=time_col, \n", + " quantiles=test_qls,\n", + " **kwargs\n", + " )\n", + " df_qls = fa.as_pandas(df_qls)\n", + " assert all(col in df_qls.columns for col in exp_q_cols)\n", + " # test monotonicity of quantiles\n", + " df_qls.apply(lambda x: x.is_monotonic_increasing, axis=1).sum() == len(exp_q_cols)\n", + " test_method_qls(distributed_timegpt.forecast)\n", + " test_method_qls(distributed_timegpt.forecast, add_history=True)\n", + " test_method_qls(distributed_timegpt.cross_validation)" + ] + }, { "cell_type": "code", "execution_count": null, @@ -867,6 +918,16 @@ "spark_diff_cols_df = spark.createDataFrame(series_diff_cols)" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#| hide\n", + "test_quantiles(spark_df, id_col=\"unique_id\", time_col=\"ds\")" + ] + }, { "cell_type": "code", "execution_count": null, @@ -941,7 +1002,26 @@ "source": [ "#| hide\n", "dask_df = dd.from_pandas(series, npartitions=2)\n", - "dask_diff_cols_df = dd.from_pandas(series_diff_cols, npartitions=2)\n", + "dask_diff_cols_df = dd.from_pandas(series_diff_cols, npartitions=2)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#| hide\n", + "test_quantiles(dask_df, id_col=\"unique_id\", time_col=\"ds\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#| hide\n", "test_forecast_dataframe(dask_df)\n", "test_forecast_dataframe_diff_cols(dask_diff_cols_df)\n", "test_anomalies_dataframe(dask_df)\n", @@ -1007,7 +1087,25 @@ "# add mock node to simulate a cluster\n", "mock_node = ray_cluster.add_node(num_cpus=2)\n", "ray_df = ray.data.from_pandas(series)\n", - "ray_diff_cols_df = ray.data.from_pandas(series_diff_cols)\n", + "ray_diff_cols_df = ray.data.from_pandas(series_diff_cols)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "test_quantiles(ray_df, id_col=\"unique_id\", time_col=\"ds\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#| hide\n", "test_forecast_dataframe(ray_df)\n", "test_forecast_dataframe_diff_cols(ray_diff_cols_df)\n", "test_anomalies_dataframe(ray_df)\n", diff --git a/nbs/docs/tutorials/10_quantile_forecasts.ipynb b/nbs/docs/tutorials/10_quantile_forecasts.ipynb new file mode 100644 index 00000000..a6a195d0 --- /dev/null +++ b/nbs/docs/tutorials/10_quantile_forecasts.ipynb @@ -0,0 +1,700 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "0241d5c1-8d11-4cb9-9259-cda5fffa7ea8", + "metadata": {}, + "source": [ + "# Quantile Forecasts" + ] + }, + { + "cell_type": "markdown", + "id": "0f73b521-05f2-4c53-b44c-d988bf8fe7b9", + "metadata": {}, + "source": [ + "Quantile forecasts are a critical component of TimeGPT's approach to time series forecasting, offering an understanding of future uncertainties. Unlike traditional point forecasts, which provide a singular expected value, quantile forecasts present specific percentiles of the forecast distribution, allowing for a more detailed exploration of potential outcomes.\n", + "\n", + "This method acknowledges the inherent randomness in future time series values by treating them as random variables with their own distribution, termed the \"forecast distribution.\" Quantile forecasts then extract key points from this distribution, each representing a different level of confidence or probability. For instance, the 25th and 75th quantiles give insights into the lower and upper quartiles of expected outcomes, respectively, while the 50th quantile, or median, offers a central estimate.\n", + "\n", + "By focusing on quantile forecasts, TimeGPT enables users to gauge not just a single expected outcome but to assess the likelihood of various scenarios. This approach is helpful for planning under uncertainty, providing a spectrum of possible future values, each attached to a specific confidence level. Thus, users can make more informed decisions by considering the full range of potential outcomes. TimeGPT uses conformal prediction to produce the quantiles." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5826b9b9-4176-4982-901c-c8c598b87b87", + "metadata": {}, + "outputs": [], + "source": [ + "#| hide\n", + "from nixtlats.utils import colab_badge" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cdf86af8-08c0-4118-bd6b-0b88a6eac3f7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/markdown": [ + "[![](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Nixtla/nixtla/blob/main/nbs/docs/tutorials/10_quantile_forecasts.ipynb)" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#| echo: false\n", + "colab_badge('docs/tutorials/10_quantile_forecasts')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f1f53486-6a02-4726-9a3e-dbd73123a8da", + "metadata": {}, + "outputs": [], + "source": [ + "#| hide\n", + "from itertools import product\n", + "\n", + "from fastcore.test import test_eq, test_fail, test_warns\n", + "from dotenv import load_dotenv" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f602562e-4035-4b73-b309-f4fd57c7a8bf", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#| hide\n", + "load_dotenv()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8a5181e9-634c-4002-9c22-d65f0701fa14", + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "from nixtlats import TimeGPT" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9872d00d-ecb1-4a14-9813-bf0c56e70392", + "metadata": {}, + "outputs": [], + "source": [ + "timegpt = TimeGPT(\n", + " # defaults to os.environ.get(\"TIMEGPT_TOKEN\")\n", + " token = 'my_token_provided_by_nixtla'\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "50eac17f-3c72-4f68-988a-1d5d877dff2b", + "metadata": {}, + "outputs": [], + "source": [ + "#| hide\n", + "timegpt = TimeGPT()" + ] + }, + { + "cell_type": "markdown", + "id": "26b99aff-aa07-44a1-b0e1-e8301f7f62bf", + "metadata": {}, + "source": [ + "When using TimeGPT for time series forecasting, you can set the quantiles you want to predict. Here's how you could do it:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "31b1e602-f8ee-49c4-8819-fcc093d64ab1", + "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", + "
timestampvalue
01949-01-01112
11949-02-01118
21949-03-01132
31949-04-01129
41949-05-01121
\n", + "
" + ], + "text/plain": [ + " timestamp value\n", + "0 1949-01-01 112\n", + "1 1949-02-01 118\n", + "2 1949-03-01 132\n", + "3 1949-04-01 129\n", + "4 1949-05-01 121" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df = pd.read_csv('https://raw.githubusercontent.com/Nixtla/transfer-learning-time-series/main/datasets/air_passengers.csv')\n", + "df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "174db3ef-71ff-4bdf-92f3-e3277bb76c43", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:nixtlats.timegpt:Validating inputs...\n", + "INFO:nixtlats.timegpt:Preprocessing dataframes...\n", + "INFO:nixtlats.timegpt:Inferred freq: MS\n", + "INFO:nixtlats.timegpt:Restricting input...\n", + "INFO:nixtlats.timegpt:Calling Forecast Endpoint...\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", + " \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", + "
timestampTimeGPTTimeGPT-q-10TimeGPT-q-20TimeGPT-q-30TimeGPT-q-40TimeGPT-q-50TimeGPT-q-60TimeGPT-q-70TimeGPT-q-80TimeGPT-q-90
01961-01-01437.837921431.987061435.043768435.384332436.402124437.837921439.273718440.291510440.632074443.688782
11961-02-01426.062714412.704926414.832806416.042401421.719165426.062714430.406262436.083026437.292621439.420502
21961-03-01463.116547437.412534444.234955446.420203450.705731463.116547475.527362479.812891481.998138488.820560
31961-04-01478.244507448.726837455.428375465.570038469.879114478.244507486.609900490.918976501.060638507.762177
41961-05-01505.646484478.409872493.154340497.990857499.138727505.646484512.154242513.302112518.138629532.883096
\n", + "
" + ], + "text/plain": [ + " timestamp TimeGPT TimeGPT-q-10 TimeGPT-q-20 TimeGPT-q-30 \\\n", + "0 1961-01-01 437.837921 431.987061 435.043768 435.384332 \n", + "1 1961-02-01 426.062714 412.704926 414.832806 416.042401 \n", + "2 1961-03-01 463.116547 437.412534 444.234955 446.420203 \n", + "3 1961-04-01 478.244507 448.726837 455.428375 465.570038 \n", + "4 1961-05-01 505.646484 478.409872 493.154340 497.990857 \n", + "\n", + " TimeGPT-q-40 TimeGPT-q-50 TimeGPT-q-60 TimeGPT-q-70 TimeGPT-q-80 \\\n", + "0 436.402124 437.837921 439.273718 440.291510 440.632074 \n", + "1 421.719165 426.062714 430.406262 436.083026 437.292621 \n", + "2 450.705731 463.116547 475.527362 479.812891 481.998138 \n", + "3 469.879114 478.244507 486.609900 490.918976 501.060638 \n", + "4 499.138727 505.646484 512.154242 513.302112 518.138629 \n", + "\n", + " TimeGPT-q-90 \n", + "0 443.688782 \n", + "1 439.420502 \n", + "2 488.820560 \n", + "3 507.762177 \n", + "4 532.883096 " + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "quantiles = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]\n", + "timegpt_quantile_fcst_df = timegpt.forecast(\n", + " df=df, h=12, \n", + " quantiles=quantiles, \n", + " time_col='timestamp', target_col='value',\n", + ")\n", + "timegpt_quantile_fcst_df.head()" + ] + }, + { + "cell_type": "markdown", + "id": "f75f9fcc-24a5-44b5-b19d-8875360d7af3", + "metadata": {}, + "source": [ + "TimeGPT will return forecasts in the format `TimeGPT-q-{int(100 * q)}` for each quantile `q`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "10fe6283-e01d-4afb-acbd-344726a0518f", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:nixtlats.timegpt:Validating inputs...\n", + "INFO:nixtlats.timegpt:Preprocessing dataframes...\n", + "INFO:nixtlats.timegpt:Inferred freq: MS\n", + "INFO:nixtlats.timegpt:Restricting input...\n", + "INFO:nixtlats.timegpt:Calling Forecast Endpoint...\n" + ] + } + ], + "source": [ + "#| hide\n", + "# test shorter horizon\n", + "level_short_horizon_df = timegpt.forecast(\n", + " df=df, h=6, quantiles=quantiles, \n", + " time_col='timestamp', target_col='value',\n", + ")\n", + "test_eq(\n", + " level_short_horizon_df.shape,\n", + " (6, 2 + len(quantiles))\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "65c9add4-da01-4767-abb2-4addd9b3bbd4", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:nixtlats.timegpt:Validating inputs...\n", + "INFO:nixtlats.timegpt:Preprocessing dataframes...\n", + "INFO:nixtlats.timegpt:Inferred freq: MS\n", + "INFO:nixtlats.timegpt:Restricting input...\n", + "INFO:nixtlats.timegpt:Calling Forecast Endpoint...\n" + ] + } + ], + "source": [ + "#| hide\n", + "cols_fcst_df = timegpt.forecast(\n", + " df=df, h=12, \n", + " quantiles=quantiles, \n", + " time_col='timestamp', target_col='value',\n", + ").columns\n", + "assert all(f'TimeGPT-q-{int(100 * q)}' in cols_fcst_df for q in quantiles)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0a2e1bab-2352-4c8d-addd-3b74fdcbdb93", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "timegpt.plot(\n", + " df, timegpt_quantile_fcst_df, \n", + " time_col='timestamp', target_col='value',\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "8f3917c3-b5d3-4950-9ff4-32627849d3e7", + "metadata": {}, + "source": [ + "It's essential to note that the choice of the quantile (or quantiles) depends on your specific use case. For high-stakes predictions, you might lean towards more conservative quantiles, such as the 10th or 20th percentile, to ensure you're prepared for worse-case scenarios. On the other hand, if you're in a situation where the cost of over-preparation is high, you might choose a quantile closer to the median, like the 50th percentile, to balance being cautious and efficient.\n", + "\n", + "For instance, if you're managing inventory for a retail business during a big sale event, opting for a lower quantile might help you avoid running out of stock, even if it means you might overstock a bit. But if you're scheduling staff for a restaurant, you might go with a quantile closer to the middle to ensure you have enough staff on hand without significantly overstaffing.\n", + "\n", + "Ultimately, the choice comes down to understanding the balance between risk and cost in your specific context, and using quantile forecasts from TimeGPT allows you to tailor your strategy to fit that balance perfectly." + ] + }, + { + "cell_type": "markdown", + "id": "ea3023d2-0c86-417c-ad19-a1a584910534", + "metadata": {}, + "source": [ + "#### Historical Forecast" + ] + }, + { + "cell_type": "markdown", + "id": "3c75269d-7cda-4bff-b18a-3a1193d8391e", + "metadata": {}, + "source": [ + "You can also compute quantile forecasts for historical forecasts adding the `add_history=True` parameter as follows:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e539081f-d5c5-4d82-b223-5b11cbd75503", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:nixtlats.timegpt:Validating inputs...\n", + "INFO:nixtlats.timegpt:Preprocessing dataframes...\n", + "INFO:nixtlats.timegpt:Inferred freq: MS\n", + "INFO:nixtlats.timegpt:Calling Forecast Endpoint...\n", + "INFO:nixtlats.timegpt:Calling Historical Forecast Endpoint...\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", + " \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", + "
timestampTimeGPTTimeGPT-q-10TimeGPT-q-20TimeGPT-q-30TimeGPT-q-40TimeGPT-q-50TimeGPT-q-60TimeGPT-q-70TimeGPT-q-80TimeGPT-q-90
01951-01-01135.483673111.937768120.020593125.848879130.828935135.483673140.138411145.118467150.946753159.029579
11951-02-01144.442398120.896493128.979318134.807604139.787660144.442398149.097136154.077192159.905478167.988304
21951-03-01157.191910133.646004141.728830147.557116152.537172157.191910161.846648166.826703172.654990180.737815
31951-04-01148.769363125.223458133.306284139.134570144.114625148.769363153.424102158.404157164.232443172.315269
41951-05-01140.472946116.927041125.009866130.838152135.818208140.472946145.127684150.107740155.936026164.018852
\n", + "
" + ], + "text/plain": [ + " timestamp TimeGPT TimeGPT-q-10 TimeGPT-q-20 TimeGPT-q-30 \\\n", + "0 1951-01-01 135.483673 111.937768 120.020593 125.848879 \n", + "1 1951-02-01 144.442398 120.896493 128.979318 134.807604 \n", + "2 1951-03-01 157.191910 133.646004 141.728830 147.557116 \n", + "3 1951-04-01 148.769363 125.223458 133.306284 139.134570 \n", + "4 1951-05-01 140.472946 116.927041 125.009866 130.838152 \n", + "\n", + " TimeGPT-q-40 TimeGPT-q-50 TimeGPT-q-60 TimeGPT-q-70 TimeGPT-q-80 \\\n", + "0 130.828935 135.483673 140.138411 145.118467 150.946753 \n", + "1 139.787660 144.442398 149.097136 154.077192 159.905478 \n", + "2 152.537172 157.191910 161.846648 166.826703 172.654990 \n", + "3 144.114625 148.769363 153.424102 158.404157 164.232443 \n", + "4 135.818208 140.472946 145.127684 150.107740 155.936026 \n", + "\n", + " TimeGPT-q-90 \n", + "0 159.029579 \n", + "1 167.988304 \n", + "2 180.737815 \n", + "3 172.315269 \n", + "4 164.018852 " + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "timegpt_quantile_fcst_df = timegpt.forecast(\n", + " df=df, h=12, \n", + " quantiles=quantiles, \n", + " time_col='timestamp', target_col='value',\n", + " add_history=True,\n", + ")\n", + "timegpt_quantile_fcst_df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1b9dddbe-0c5a-4d21-abcf-f664e176c7a7", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "timegpt.plot(\n", + " df, timegpt_quantile_fcst_df, \n", + " time_col='timestamp', target_col='value',\n", + ")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "python3", + "language": "python", + "name": "python3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/nbs/docs/tutorials/4_prediction_intervals.ipynb b/nbs/docs/tutorials/4_prediction_intervals.ipynb index a9c2d93d..f33bf636 100644 --- a/nbs/docs/tutorials/4_prediction_intervals.ipynb +++ b/nbs/docs/tutorials/4_prediction_intervals.ipynb @@ -96,16 +96,7 @@ "execution_count": null, "id": "8a5181e9-634c-4002-9c22-d65f0701fa14", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/ubuntu/miniconda/envs/nixtlats/lib/python3.11/site-packages/statsforecast/core.py:25: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", - " from tqdm.autonotebook import tqdm\n" - ] - } - ], + "outputs": [], "source": [ "import pandas as pd\n", "from nixtlats import TimeGPT" @@ -413,10 +404,10 @@ "#| hide\n", "test_level = [80, 90.5]\n", "cols_fcst_df = timegpt.forecast(\n", - " df=df, h=12, level=[80, 90.5], \n", + " df=df, h=12, level=test_level, \n", " time_col='timestamp', target_col='value',\n", ").columns\n", - "assert all(f'TimeGPT-{pos}-{lv}' for pos, lv in product(test_level, ['lo', 'hi']) )" + "assert all(f'TimeGPT-{pos}-{lv}' in cols_fcst_df for pos, lv in product(['lo', 'hi'], test_level) )" ] }, { @@ -427,7 +418,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -520,19 +511,19 @@ " 0\n", " 1951-01-01\n", " 135.483673\n", - " 111.937767\n", - " 105.262830\n", + " 111.937768\n", + " 105.262831\n", " 159.029579\n", " 165.704516\n", " \n", " \n", " 1\n", " 1951-02-01\n", - " 144.442413\n", - " 120.896508\n", - " 114.221571\n", - " 167.988319\n", - " 174.663256\n", + " 144.442398\n", + " 120.896493\n", + " 114.221556\n", + " 167.988304\n", + " 174.663241\n", " \n", " \n", " 2\n", @@ -546,11 +537,11 @@ " \n", " 3\n", " 1951-04-01\n", - " 148.769379\n", - " 125.223473\n", - " 118.548536\n", - " 172.315284\n", - " 178.990221\n", + " 148.769363\n", + " 125.223458\n", + " 118.548521\n", + " 172.315269\n", + " 178.990206\n", " \n", " \n", " 4\n", @@ -567,17 +558,17 @@ ], "text/plain": [ " timestamp TimeGPT TimeGPT-lo-80 TimeGPT-lo-90 TimeGPT-hi-80 \\\n", - "0 1951-01-01 135.483673 111.937767 105.262830 159.029579 \n", - "1 1951-02-01 144.442413 120.896508 114.221571 167.988319 \n", + "0 1951-01-01 135.483673 111.937768 105.262831 159.029579 \n", + "1 1951-02-01 144.442398 120.896493 114.221556 167.988304 \n", "2 1951-03-01 157.191910 133.646004 126.971067 180.737815 \n", - "3 1951-04-01 148.769379 125.223473 118.548536 172.315284 \n", + "3 1951-04-01 148.769363 125.223458 118.548521 172.315269 \n", "4 1951-05-01 140.472946 116.927041 110.252104 164.018852 \n", "\n", " TimeGPT-hi-90 \n", "0 165.704516 \n", - "1 174.663256 \n", + "1 174.663241 \n", "2 187.412752 \n", - "3 178.990221 \n", + "3 178.990206 \n", "4 170.693789 " ] }, @@ -603,7 +594,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] diff --git a/nbs/timegpt.ipynb b/nbs/timegpt.ipynb index b67a89b7..673fb095 100644 --- a/nbs/timegpt.ipynb +++ b/nbs/timegpt.ipynb @@ -163,6 +163,7 @@ " target_col: str = 'y',\n", " freq: str = None,\n", " level: Optional[List[Union[int, float]]] = None,\n", + " quantiles: Optional[List[float]] = None,\n", " finetune_steps: int = 0,\n", " finetune_loss: str = 'default',\n", " clean_ex_first: bool = True,\n", @@ -179,7 +180,7 @@ " self.time_col = time_col\n", " self.target_col = target_col\n", " self.base_freq = freq\n", - " self.level = level\n", + " self.level, self.quantiles = self._prepare_level_and_quantiles(level, quantiles)\n", " self.finetune_steps = finetune_steps\n", " self.finetune_loss = finetune_loss\n", " self.clean_ex_first = clean_ex_first\n", @@ -197,6 +198,26 @@ " self.input_size: int\n", " self.model_horizon: int\n", "\n", + " @staticmethod\n", + " def _prepare_level_and_quantiles(\n", + " level: Optional[List[Union[int, float]]], \n", + " quantiles: Optional[List[float]],\n", + " ):\n", + " if (level is not None) and (quantiles is not None):\n", + " raise Exception(\n", + " \"you should include `level` or `quantiles` but not both.\"\n", + " )\n", + " if quantiles is None:\n", + " return level, quantiles\n", + " # we recover level from quantiles\n", + " if not all(0 < q < 1 for q in quantiles):\n", + " raise Exception(\n", + " \"`quantiles` should lie between 0 and 1\"\n", + " )\n", + " level = [abs(int(100 - 200 * q)) for q in quantiles]\n", + " return level, quantiles\n", + " \n", + "\n", " def _retry_strategy(self):\n", " def after_retry(retry_state: RetryCallState):\n", " \"\"\"Called after each retry attempt.\"\"\"\n", @@ -260,7 +281,7 @@ " X_df['ds'] = X_df['ds'].astype(str)\n", " return df, X_df\n", "\n", - " def transform_outputs(self, fcst_df: pd.DataFrame):\n", + " def transform_outputs(self, fcst_df: pd.DataFrame, level_to_quantiles: bool = False):\n", " renamer = {\n", " 'unique_id': self.id_col,\n", " 'ds': self.time_col,\n", @@ -269,6 +290,21 @@ " if self.drop_uid:\n", " fcst_df = fcst_df.drop(columns='unique_id')\n", " fcst_df = fcst_df.rename(columns=renamer)\n", + " # transfom levels to quantiles if needed\n", + " if level_to_quantiles and self.quantiles is not None:\n", + " cols = [col for col in fcst_df.columns if ('-lo-' not in col) and ('-hi-' not in col)]\n", + " for q in sorted(self.quantiles):\n", + " if q == 0.5:\n", + " col = 'TimeGPT'\n", + " else:\n", + " lv = int(100 - 200 * q)\n", + " hi_or_lo = 'lo' if lv > 0 else 'hi'\n", + " lv = abs(lv)\n", + " col = f\"TimeGPT-{hi_or_lo}-{lv}\"\n", + " q_col = f\"TimeGPT-q-{int(q * 100)}\"\n", + " fcst_df[q_col] = fcst_df[col].values\n", + " cols.append(q_col)\n", + " fcst_df = fcst_df[cols]\n", " return fcst_df\n", "\n", " def infer_freq(self, df: pd.DataFrame):\n", @@ -543,7 +579,7 @@ " fitted_df = pd.DataFrame(**response_timegpt['forecast'])\n", " fitted_df = fitted_df.drop(columns='y')\n", " fcst_df = pd.concat([fitted_df, fcst_df]).sort_values(['unique_id', 'ds'])\n", - " fcst_df = self.transform_outputs(fcst_df)\n", + " fcst_df = self.transform_outputs(fcst_df, level_to_quantiles=True)\n", " return fcst_df\n", "\n", " def detect_anomalies(self, df: pd.DataFrame):\n", @@ -800,6 +836,7 @@ " target_col: str = 'y',\n", " X_df: Optional[pd.DataFrame] = None,\n", " level: Optional[List[Union[int, float]]] = None,\n", + " quantiles: Optional[List[float]] = None,\n", " finetune_steps: int = 0,\n", " finetune_loss: str = 'default',\n", " clean_ex_first: bool = True,\n", @@ -822,6 +859,7 @@ " target_col=target_col,\n", " freq=freq,\n", " level=level,\n", + " quantiles=quantiles,\n", " finetune_steps=finetune_steps,\n", " finetune_loss=finetune_loss,\n", " clean_ex_first=clean_ex_first,\n", @@ -888,6 +926,7 @@ " time_col: str = \"ds\",\n", " target_col: str = \"y\",\n", " level: Optional[List[Union[int, float]]] = None,\n", + " quantiles: Optional[List[float]] = None,\n", " validate_token: bool = False,\n", " n_windows: int = 1,\n", " step_size: Optional[int] = None,\n", @@ -911,6 +950,7 @@ " target_col=target_col,\n", " freq=freq,\n", " level=level,\n", + " quantiles=quantiles,\n", " finetune_steps=finetune_steps,\n", " finetune_loss=finetune_loss,\n", " clean_ex_first=clean_ex_first,\n", @@ -1065,6 +1105,7 @@ " target_col: str = 'y',\n", " X_df: Optional[pd.DataFrame] = None,\n", " level: Optional[List[Union[int, float]]] = None,\n", + " quantiles: Optional[List[float]] = None,\n", " finetune_steps: int = 0,\n", " finetune_loss: str = 'default',\n", " clean_ex_first: bool = True,\n", @@ -1106,6 +1147,13 @@ " DataFrame with [`unique_id`, `ds`] columns and `df`'s future exogenous.\n", " level : List[float], optional (default=None)\n", " Confidence levels between 0 and 100 for prediction intervals.\n", + " quantiles : List[float], optional (default=None)\n", + " Quantiles to forecast, list between (0, 1).\n", + " `level` and `quantiles` should not be used simultaneously.\n", + " The output dataframe will have the quantile columns\n", + " formatted as TimeGPT-q-{int(100 * q)} for each q.\n", + " 100 * q represents percentiles but we choose this notation\n", + " to avoid handling __dots__ (.) in names.\n", " finetune_steps : int (default=0)\n", " Number of steps used to finetune TimeGPT in the\n", " new data.\n", @@ -1154,6 +1202,7 @@ " target_col=target_col,\n", " X_df=X_df,\n", " level=level,\n", + " quantiles=quantiles,\n", " finetune_steps=finetune_steps,\n", " finetune_loss=finetune_loss,\n", " clean_ex_first=clean_ex_first,\n", @@ -1175,6 +1224,7 @@ " target_col=target_col,\n", " X_df=X_df,\n", " level=level,\n", + " quantiles=quantiles,\n", " finetune_steps=finetune_steps,\n", " finetune_loss=finetune_loss,\n", " clean_ex_first=clean_ex_first,\n", @@ -1299,6 +1349,7 @@ " time_col: str = \"ds\",\n", " target_col: str = \"y\",\n", " level: Optional[List[Union[int, float]]] = None,\n", + " quantiles: Optional[List[float]] = None,\n", " validate_token: bool = False,\n", " n_windows: int = 1,\n", " step_size: Optional[int] = None,\n", @@ -1338,7 +1389,14 @@ " target_col : str (default='y')\n", " Column that contains the target.\n", " level : float (default=99)\n", - " Confidence level between 0 and 100 for detecting the anomalies.\n", + " Confidence level between 0 and 100 for prediction intervals.\n", + " quantiles : List[float], optional (default=None)\n", + " Quantiles to forecast, list between (0, 1).\n", + " `level` and `quantiles` should not be used simultaneously.\n", + " The output dataframe will have the quantile columns\n", + " formatted as TimeGPT-q-{int(100 * q)} for each q.\n", + " 100 * q represents percentiles but we choose this notation\n", + " to avoid handling __dots__ (.) in names.\n", " validate_token : bool (default=False)\n", " If True, validates token before\n", " sending requests.\n", @@ -1387,6 +1445,7 @@ " time_col=time_col,\n", " target_col=target_col,\n", " level=level,\n", + " quantiles=quantiles,\n", " finetune_steps=finetune_steps,\n", " finetune_loss=finetune_loss,\n", " clean_ex_first=clean_ex_first,\n", @@ -1408,6 +1467,7 @@ " time_col=time_col,\n", " target_col=target_col,\n", " level=level,\n", + " quantiles=quantiles,\n", " finetune_steps=finetune_steps,\n", " finetune_loss=finetune_loss,\n", " clean_ex_first=clean_ex_first,\n", @@ -1583,6 +1643,44 @@ " )" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#| hide\n", + "# test quantiles\n", + "test_fail(\n", + " lambda: timegpt.forecast(\n", + " df=df, \n", + " h=12, \n", + " time_col='timestamp', \n", + " target_col='value', \n", + " level=[80], \n", + " quantiles=[0.2, 0.3]\n", + " ),\n", + " contains='not both'\n", + ")\n", + "test_qls = list(np.arange(0.1, 1, 0.1))\n", + "exp_q_cols = [f\"TimeGPT-q-{int(100 * q)}\" for q in test_qls]\n", + "def test_method_qls(method, **kwargs):\n", + " df_qls = method(\n", + " df=df, \n", + " h=12, \n", + " time_col='timestamp', \n", + " target_col='value', \n", + " quantiles=test_qls,\n", + " **kwargs\n", + " )\n", + " assert all(col in df_qls.columns for col in exp_q_cols)\n", + " # test monotonicity of quantiles\n", + " df_qls.apply(lambda x: x.is_monotonic_increasing, axis=1).sum() == len(exp_q_cols)\n", + "test_method_qls(timegpt.forecast)\n", + "test_method_qls(timegpt.forecast, add_history=True)\n", + "test_method_qls(timegpt.cross_validation)" + ] + }, { "cell_type": "code", "execution_count": null, diff --git a/nixtlats/_modidx.py b/nixtlats/_modidx.py index c91e07ed..514aee26 100644 --- a/nixtlats/_modidx.py +++ b/nixtlats/_modidx.py @@ -82,6 +82,8 @@ 'nixtlats.timegpt._TimeGPTModel.__init__': ('timegpt.html#_timegptmodel.__init__', 'nixtlats/timegpt.py'), 'nixtlats.timegpt._TimeGPTModel._call_api': ( 'timegpt.html#_timegptmodel._call_api', 'nixtlats/timegpt.py'), + 'nixtlats.timegpt._TimeGPTModel._prepare_level_and_quantiles': ( 'timegpt.html#_timegptmodel._prepare_level_and_quantiles', + 'nixtlats/timegpt.py'), 'nixtlats.timegpt._TimeGPTModel._retry_strategy': ( 'timegpt.html#_timegptmodel._retry_strategy', 'nixtlats/timegpt.py'), 'nixtlats.timegpt._TimeGPTModel.add_date_features': ( 'timegpt.html#_timegptmodel.add_date_features', diff --git a/nixtlats/distributed/timegpt.py b/nixtlats/distributed/timegpt.py index 9fb9a243..0bb94c63 100644 --- a/nixtlats/distributed/timegpt.py +++ b/nixtlats/distributed/timegpt.py @@ -124,6 +124,7 @@ def forecast( target_col: str = "y", X_df: Optional[fugue.AnyDataFrame] = None, level: Optional[List[Union[int, float]]] = None, + quantiles: Optional[List[float]] = None, finetune_steps: int = 0, finetune_loss: str = "default", clean_ex_first: bool = True, @@ -141,6 +142,7 @@ def forecast( time_col=time_col, target_col=target_col, level=level, + quantiles=quantiles, finetune_steps=finetune_steps, finetune_loss=finetune_loss, clean_ex_first=clean_ex_first, @@ -151,7 +153,10 @@ def forecast( model=model, ) schema = self._get_forecast_schema( - id_col=id_col, time_col=time_col, level=level + id_col=id_col, + time_col=time_col, + level=level, + quantiles=quantiles, ) fcst_df = self._distribute_method( method=self._forecast if X_df is None else self._forecast_x, @@ -212,6 +217,7 @@ def cross_validation( time_col: str = "ds", target_col: str = "y", level: Optional[List[Union[int, float]]] = None, + quantiles: Optional[List[float]] = None, finetune_steps: int = 0, finetune_loss: str = "default", clean_ex_first: bool = True, @@ -230,6 +236,7 @@ def cross_validation( time_col=time_col, target_col=target_col, level=level, + quantiles=quantiles, finetune_steps=finetune_steps, finetune_loss=finetune_loss, clean_ex_first=clean_ex_first, @@ -241,7 +248,11 @@ def cross_validation( step_size=step_size, ) schema = self._get_forecast_schema( - id_col=id_col, time_col=time_col, level=level, cv=True + id_col=id_col, + time_col=time_col, + level=level, + quantiles=quantiles, + cv=True, ) fcst_df = self._distribute_method( method=self._cross_validation, @@ -299,15 +310,21 @@ def _cross_validation( return timegpt._cross_validation(df=df, **kwargs) @staticmethod - def _get_forecast_schema(id_col, time_col, level, cv=False): + def _get_forecast_schema(id_col, time_col, level, quantiles, cv=False): schema = f"{id_col}:string,{time_col}:datetime" if cv: schema = f"{schema},cutoff:datetime" schema = f"{schema},TimeGPT:double" + if (level is not None) and (quantiles is not None): + raise Exception("you should include `level` or `quantiles` but not both.") if level is not None: level = sorted(level) schema = f'{schema},{",".join([f"TimeGPT-lo-{lv}:double" for lv in reversed(level)])}' schema = f'{schema},{",".join([f"TimeGPT-hi-{lv}:double" for lv in level])}' + if quantiles is not None: + quantiles = sorted(quantiles) + q_cols = [f"TimeGPT-q-{int(q * 100)}:double" for q in quantiles] + schema = f'{schema},{",".join(q_cols)}' return Schema(schema) @staticmethod diff --git a/nixtlats/timegpt.py b/nixtlats/timegpt.py index 326d9f9a..13c2903d 100644 --- a/nixtlats/timegpt.py +++ b/nixtlats/timegpt.py @@ -99,6 +99,7 @@ def __init__( target_col: str = "y", freq: str = None, level: Optional[List[Union[int, float]]] = None, + quantiles: Optional[List[float]] = None, finetune_steps: int = 0, finetune_loss: str = "default", clean_ex_first: bool = True, @@ -115,7 +116,7 @@ def __init__( self.time_col = time_col self.target_col = target_col self.base_freq = freq - self.level = level + self.level, self.quantiles = self._prepare_level_and_quantiles(level, quantiles) self.finetune_steps = finetune_steps self.finetune_loss = finetune_loss self.clean_ex_first = clean_ex_first @@ -133,6 +134,21 @@ def __init__( self.input_size: int self.model_horizon: int + @staticmethod + def _prepare_level_and_quantiles( + level: Optional[List[Union[int, float]]], + quantiles: Optional[List[float]], + ): + if (level is not None) and (quantiles is not None): + raise Exception("you should include `level` or `quantiles` but not both.") + if quantiles is None: + return level, quantiles + # we recover level from quantiles + if not all(0 < q < 1 for q in quantiles): + raise Exception("`quantiles` should lie between 0 and 1") + level = [abs(int(100 - 200 * q)) for q in quantiles] + return level, quantiles + def _retry_strategy(self): def after_retry(retry_state: RetryCallState): """Called after each retry attempt.""" @@ -202,7 +218,9 @@ def transform_inputs(self, df: pd.DataFrame, X_df: pd.DataFrame): X_df["ds"] = X_df["ds"].astype(str) return df, X_df - def transform_outputs(self, fcst_df: pd.DataFrame): + def transform_outputs( + self, fcst_df: pd.DataFrame, level_to_quantiles: bool = False + ): renamer = { "unique_id": self.id_col, "ds": self.time_col, @@ -211,6 +229,25 @@ def transform_outputs(self, fcst_df: pd.DataFrame): if self.drop_uid: fcst_df = fcst_df.drop(columns="unique_id") fcst_df = fcst_df.rename(columns=renamer) + # transfom levels to quantiles if needed + if level_to_quantiles and self.quantiles is not None: + cols = [ + col + for col in fcst_df.columns + if ("-lo-" not in col) and ("-hi-" not in col) + ] + for q in sorted(self.quantiles): + if q == 0.5: + col = "TimeGPT" + else: + lv = int(100 - 200 * q) + hi_or_lo = "lo" if lv > 0 else "hi" + lv = abs(lv) + col = f"TimeGPT-{hi_or_lo}-{lv}" + q_col = f"TimeGPT-q-{int(q * 100)}" + fcst_df[q_col] = fcst_df[col].values + cols.append(q_col) + fcst_df = fcst_df[cols] return fcst_df def infer_freq(self, df: pd.DataFrame): @@ -516,7 +553,7 @@ def forecast( fitted_df = pd.DataFrame(**response_timegpt["forecast"]) fitted_df = fitted_df.drop(columns="y") fcst_df = pd.concat([fitted_df, fcst_df]).sort_values(["unique_id", "ds"]) - fcst_df = self.transform_outputs(fcst_df) + fcst_df = self.transform_outputs(fcst_df, level_to_quantiles=True) return fcst_df def detect_anomalies(self, df: pd.DataFrame): @@ -751,6 +788,7 @@ def _forecast( target_col: str = "y", X_df: Optional[pd.DataFrame] = None, level: Optional[List[Union[int, float]]] = None, + quantiles: Optional[List[float]] = None, finetune_steps: int = 0, finetune_loss: str = "default", clean_ex_first: bool = True, @@ -771,6 +809,7 @@ def _forecast( target_col=target_col, freq=freq, level=level, + quantiles=quantiles, finetune_steps=finetune_steps, finetune_loss=finetune_loss, clean_ex_first=clean_ex_first, @@ -835,6 +874,7 @@ def _cross_validation( time_col: str = "ds", target_col: str = "y", level: Optional[List[Union[int, float]]] = None, + quantiles: Optional[List[float]] = None, validate_token: bool = False, n_windows: int = 1, step_size: Optional[int] = None, @@ -856,6 +896,7 @@ def _cross_validation( target_col=target_col, freq=freq, level=level, + quantiles=quantiles, finetune_steps=finetune_steps, finetune_loss=finetune_loss, clean_ex_first=clean_ex_first, @@ -1005,6 +1046,7 @@ def forecast( target_col: str = "y", X_df: Optional[pd.DataFrame] = None, level: Optional[List[Union[int, float]]] = None, + quantiles: Optional[List[float]] = None, finetune_steps: int = 0, finetune_loss: str = "default", clean_ex_first: bool = True, @@ -1046,6 +1088,13 @@ def forecast( DataFrame with [`unique_id`, `ds`] columns and `df`'s future exogenous. level : List[float], optional (default=None) Confidence levels between 0 and 100 for prediction intervals. + quantiles : List[float], optional (default=None) + Quantiles to forecast, list between (0, 1). + `level` and `quantiles` should not be used simultaneously. + The output dataframe will have the quantile columns + formatted as TimeGPT-q-{int(100 * q)} for each q. + 100 * q represents percentiles but we choose this notation + to avoid handling __dots__ (.) in names. finetune_steps : int (default=0) Number of steps used to finetune TimeGPT in the new data. @@ -1094,6 +1143,7 @@ def forecast( target_col=target_col, X_df=X_df, level=level, + quantiles=quantiles, finetune_steps=finetune_steps, finetune_loss=finetune_loss, clean_ex_first=clean_ex_first, @@ -1115,6 +1165,7 @@ def forecast( target_col=target_col, X_df=X_df, level=level, + quantiles=quantiles, finetune_steps=finetune_steps, finetune_loss=finetune_loss, clean_ex_first=clean_ex_first, @@ -1239,6 +1290,7 @@ def cross_validation( time_col: str = "ds", target_col: str = "y", level: Optional[List[Union[int, float]]] = None, + quantiles: Optional[List[float]] = None, validate_token: bool = False, n_windows: int = 1, step_size: Optional[int] = None, @@ -1278,7 +1330,14 @@ def cross_validation( target_col : str (default='y') Column that contains the target. level : float (default=99) - Confidence level between 0 and 100 for detecting the anomalies. + Confidence level between 0 and 100 for prediction intervals. + quantiles : List[float], optional (default=None) + Quantiles to forecast, list between (0, 1). + `level` and `quantiles` should not be used simultaneously. + The output dataframe will have the quantile columns + formatted as TimeGPT-q-{int(100 * q)} for each q. + 100 * q represents percentiles but we choose this notation + to avoid handling __dots__ (.) in names. validate_token : bool (default=False) If True, validates token before sending requests. @@ -1327,6 +1386,7 @@ def cross_validation( time_col=time_col, target_col=target_col, level=level, + quantiles=quantiles, finetune_steps=finetune_steps, finetune_loss=finetune_loss, clean_ex_first=clean_ex_first, @@ -1348,6 +1408,7 @@ def cross_validation( time_col=time_col, target_col=target_col, level=level, + quantiles=quantiles, finetune_steps=finetune_steps, finetune_loss=finetune_loss, clean_ex_first=clean_ex_first,